Task.WaitAll 的线程本地对象

Question

我有少量任务，我想使用 Task.WaitAll 并行运行它们。这就是我现在所拥有的：

type System.Threading.Tasks.Task with
  static member WaitAll(ts) =
    Task.WaitAll [| for t in ts -> t :> Task |]

let processf p fs =
  let rand = Random ()
  let ts = fs |> Array.map (fun f -> Task.Factory.StartNew(fun () -> p(f, rand)))
  Task.WaitAll(ts)
  ts |> Array.map (fun t -> t.Result)

问题是 Random 不是线程安全的（选择 Random 类仅用于说明目的）。如何为每个线程创建一个对象，而不是为每个任务创建一个对象，这样很浪费？

编辑：

像 Brian 和 Daniel 的建议一样使用 ThreadStatic 是一个很好的方法，特别是对于工厂类。不过，我更喜欢 Reed 和 Tomas 建议的 ThreadLocal，因为它看起来更简单。我同意使用主Random有点过于复杂。以下是我保留以供将来参考的混合解决方案：

let processf p fs =
  use localRand = new ThreadLocal<_>(
                       fun() -> Random(Thread.CurrentThread.ManagedThreadId))
  let ts = fs |> Array.map (fun f -> 
                          Task.Factory.StartNew(fun () -> p(f, localRand.Value)))
  Task.WaitAll(ts)
  ts |> Array.map (fun t -> t.Result)

Answer 1

您可以将线程特定的状态放入工厂类中并将其标记为ThreadStatic。

type PerThread =

  [<ThreadStatic; DefaultValue>]
  static val mutable private random : Random

  static member Random = 
    match PerThread.random with
    | null -> PerThread.random <- Random(Thread.CurrentThread.ManagedThreadId)
    | _ -> ()
    PerThread.random

然后你可以这样做：

let process p fs =
  let ts = fs |> Array.map (fun f -> 
    Task.Factory.StartNew(fun () -> p(f, PerThread.Random)))
  Task.WaitAll(ts)
  ts |> Array.map (fun (t: Task) -> t.Result)

Answer 2

您可以使用 ThreadLocal<'T> 类 来存储 Random 实例。这将提供一个线程本地随机值，可以在任务完成后将其释放。

Answer 3

StackOverflow 上最近的 F# 问题 完全实现了您的功能正在寻找。

使用线程本地（线程静态）存储是可行的方法，但您应该小心 - 当所有线程同时启动时，它们也有可能获得相同的初始种子。为了解决这个问题，上面的实现使用了一个受锁保护的 master Random，该锁用于为各个线程生成种子。

Answer 4

您可以将“rand”声明为 ThreadStatic。或者，TPL 中有一些允许 TLS 的 API；我不知道全部，但请参阅此处< /a>，可能是寻找其他人的起点。 （希望其他人能够发布更多细节或完善这个答案。）

Answer 5

我认为您不需要本地线程。您可以使用当前线程 ID 在每个任务中创建新的 Random 对象。
例如：

Task.Factory.StartNew(fun () -> p(f, new Random(Thread.CurrentThread.ManagedThreadId))))

我认为这比跟踪线程局部变量更简单、更容易理解。