所谓 Futures 就是指：有时候在你使用某一个值之前需要先对其进行计算。这种情况下，你就可以在另一个处理器上进行该值的计算，到使用时，该值就已经计算完毕了。

    Futures 模式通过闭包和通道可以很容易实现，类似于生成器，不同地方在于 Futures 需要返回一个值。

    参考条目文献给出了一个很精彩的例子：假设我们有一个矩阵类型，我们需要计算两个矩阵 A 和 B 乘积的逆，首先我们通过函数 Inverse(M) 分别对其进行求逆运算，在将结果相乘。如下函数 InverseProduct() 实现了如上过程：

    1. func InverseProduct(a Matrix, b Matrix) {
    2.     a_inv := Inverse(a)
    3.     b_inv := Inverse(b)
    4.     return Product(a_inv, b_inv)
    5. }

    在这个例子中，a 和 b 的求逆矩阵需要先被计算。那么为什么在计算 b 的逆矩阵时，需要等待 a 的逆计算完成呢？显然不必要，这两个求逆运算其实可以并行执行的。换句话说，调用 Product 函数只需要等到 a_inv 和 b_inv 的计算完成。如下代码实现了并行计算方式：

    1. func InverseProduct(a Matrix, b Matrix) {
    2.     a_inv_future := InverseFuture(a)   // start as a goroutine
    3.     b_inv_future := InverseFuture(b)   // start as a goroutine
    4.     a_inv := <-a_inv_future
    5.     b_inv := <-b_inv_future
    6.     return Product(a_inv, b_inv)
    7. }

    InverseFuture 函数起了一个 goroutine 协程，在其执行闭包运算，该闭包会将矩阵求逆结果放入到 future 通道中：

    1. func InverseFuture(a Matrix) {
    2.     future := make(chan Matrix)
    3.     go func() {
    4.         future <- Inverse(a)
    5.     }()
    6.     return future
    7. }

    当开发一个计算密集型库时，使用 Futures 模式设计 API 接口是很有意义的。在你的包使用 Futures 模式，且能保持友好的 API 接口。此外，Futures 可以通过一个异步的 API 暴露出来。这样你可以以最小的成本将包中的并行计算移到用户代码中。（参见参考文件 18：www.golangpatterns.info/concurrency…）