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的论文。引用论文的相关部分：

期货是任务的变体，其中相关的行为计算结果：
delegate T Func<T>();
class Future<T> : Task{
  Future (Func<T> function);
  T Value{ get; } // does an implicit wait
}
将使用具有Func类型的委托构建future T是委托的返回类型。未来的结果是通过Value属性检索，该属性在内部调用Wait 确保任务已完成且结果值已经完成计算。由于调用了Wait，调用Value将抛出任何异常在计算未来价值期间提出的。一罐将期货视为返回结果值或异常值。

现在，您可以使用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）中详细了解该模式。

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

1 个答案: