Tasks.Future.Create 是什么/在哪里，它的等价物是什么？

Question

我正在查找this article on F# optimizations，并对提到Tasks.Future.Create 的行感到好奇。它似乎在将来创建一个任务，并且似乎遵循Futures and Promises 模式。在其他一些地方也提到了相同的方法，例如在 this thread on benchmarking F#, Java, C# 中，它也在 F# 代码中使用。

我想知道，上述 F# 代码（复制到此处以供参考，以防链接失效）是否与 Tasks.Task<T> 之类的代码完全一样，还是应该使用不同的线程原语？

open System.Threading

let inline sort cmp (a: _ array) =
  let inline swap i j =
    let t = a.[i]
    a.[i] <- a.[j]
    a.[j] <- t
  let rec qsort l u =
    if l < u then
      swap l ((l + u) / 2)
      let mutable m = l
      for i=l+1 to u do
        if cmp a.[i] a.[l] < 0 then
          m <- m + 1
          swap m i
      swap l m
      if u-l > 1000 then
        let m = m
        let f = Tasks.Future.Create(fun () -> qsort l (m-1))
        qsort (m+1) u
        f.Value
      else
        qsort l (m-1)
        qsort (m+1) u
  qsort 0 (a.Length-1)

let inline cmp (str: _ array) i j =
  let rec cmp i j =
    if i=str.Length then 1 else
      if j=str.Length then -1 else
        let c = compare str.[i] str.[j] in
        if c<>0 then c else
          cmp (i+1) (j+1)
  cmp i j

let bwt (str: byte array) =
  let n = str.Length
  let a = Array.init n (fun i -> i)
  sort (fun i j -> cmp str i j) a
  Array.init n (fun i -> str.[(a.[i] + n - 1) % n])

注意：我猜这是 TPL 预览版中的一种方法。

Answer 1

你是对的。它可以追溯到一篇关于 Design of Task Parallel Library 的论文。引用论文的相关部分：

Futures 是任务的变体，其中关联的操作计算 结果：

delegate T Func<T>();
class Future<T> : Task{
  Future (Func<T> function);
  T Value{ get; } // does an implicit wait
}

Future 由具有 Func 类型的委托构造，其中 T 是委托的返回类型。未来的结果是 通过 Value 属性检索，该属性在内部调用 Wait 确保任务已完成且结果值已 计算。由于调用了 Wait ，调用 Value 会抛出任何异常 这是在计算未来价值时提出的。一罐 将期货视为返回结果值或异常 价值。

现在在 TPL 中，您可以使用 Task 类完成所有操作。正如@Daniel 所说，你的例子可以写成：

let f = Task.Factory.StartNew(fun () -> qsort l (m-1))
qsort (m+1) u
f.Result

我认为，当您拥有具有复杂依赖关系的任务图时，未来模式会更加有用。您可能想在优秀的书籍Parallel Programming with Microsoft .NET（其中包含许多优秀的F# samples）中了解有关该模式的更多信息。