0

我正在查找有关 F# 优化的这篇文章，并对提及Tasks.Future.Create. 它似乎在未来创建一个任务，并且似乎遵循Futures 和 Promise模式。在其他一些地方也提到了相同的方法，例如在基准测试 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 预览版中的一种方法。

4

1 回答 1

3

你是对的。它可以追溯到一篇关于任务并行库设计的论文。引用论文的相关部分：

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

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

未来由具有 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# 示例）一书中了解有关该模式的更多信息。

于 2013-01-07T20:12:40.197 回答