根据以下场景分配线程的最有效方法是什么？

Question

我可以在任何时候最多同时运行 5 个线程，这利用 5 个独立的硬件来加速一些复杂计算的计算并返回结果。每个硬件的 API（仅包含一种方法）都不是线程安全的，并且只能在任何时间点在单个线程上运行。计算完成后，可以重新使用相同的线程在相同或不同的硬件上启动另一个计算，具体取决于可用性。每个计算都是独立的，不依赖于其他计算的结果。因此，最多 5 个线程可以以任意顺序完成其执行。

什么是最有效的 C#（使用 .Net Framework 2.0）编码解决方案，用于跟踪哪些硬件是免费/可用的，并将线程分配给适当的硬件 API 以执行计算？请注意，除了 5 个并发运行线程的限制之外，我无法控制线程何时或如何被触发。

如果我错了，请纠正我，但首选无锁解决方案，因为我相信它会提高效率和更具可扩展性的解决方案。

还请注意，这不是家庭作业，虽然听起来很像……

Answer 1

.NET 提供了一个可以使用的线程池。 System.Threading.ThreadPool.QueueUserWorkItem() 告诉池中的一个线程为你做一些工作。

如果我设计这个，我不会专注于将线程映射到您的硬件资源。相反，我会为每个硬件资源公开一个可锁定的对象——这可以只是一个包含 5 个对象的数组或队列。然后，对于您拥有的每一位计算，请致电QueueUserWorkItem()。在传递给 QUWI 的方法中，找到下一个可用的可锁定对象并将其锁定（也称为出列）。使用硬件资源，然后重新入队对象，退出 QUWI 方法。

拨打 QUWI 多少次都没有关系；最多可以持有 5 把锁，每把锁都可以保护对您的特殊硬件设备的一个实例的访问。

doc page for Monitor.Enter() 展示了如何创建一个可由多个工作人员访问的安全（阻塞）队列。在 .NET 4.0 中，您将使用 the builtin BlockingCollection - 这是同一回事。

这基本上就是你想要的。除了不要打电话给Thread.Create()。使用线程池。

引用：Advantage of using Thread.Start vs QueueUserWorkItem

---

// assume the SafeQueue class from the cited doc page. 
SafeQueue<SpecialHardware> q = new SafeQueue<SpecialHardware>()

// set up the queue with objects protecting the 5 magic stones
private void Setup() 
{
    for (int i=0; i< 5; i++) 
    {
       q.Enqueue(GetInstanceOfSpecialHardware(i));
    }
}


// something like this gets called many times, by QueueUserWorkItem()
public void DoWork(WorkDescription d)
{
    d.DoPrepWork();

    // gain access to one of the special hardware devices
    SpecialHardware shw = q.Dequeue();
    try 
    {
        shw.DoTheMagicThing();
    }
    finally 
    {
        // ensure no matter what happens the HW device is released
        q.Enqueue(shw);
        // at this point another worker can use it.
    }

    d.DoFollowupWork(); 
}

Answer 2

无锁解决方案仅在计算时间非常短的情况下才有用。

我将为每个将作业排入队列并在每次作业完成时调用回调的硬件线程创建一个外观。

类似：

public class Job
{
    public string JobInfo {get;set;}
    public Action<Job> Callback {get;set;}
}

public class MyHardwareService
{
    Queue<Job> _jobs = new Queue<Job>();
    Thread _hardwareThread;
    ManualResetEvent _event = new ManualResetEvent(false);

    public MyHardwareService()
    {
        _hardwareThread = new Thread(WorkerFunc);
    }

    public void Enqueue(Job job)
    {
      lock (_jobs)
        _jobs.Enqueue(job);

       _event.Set();
    }

    public void WorkerFunc()
    {
        while(true)
        {
             _event.Wait(Timeout.Infinite);
             Job currentJob;
             lock (_queue)
             {
                currentJob = jobs.Dequeue();
             }

             //invoke hardware here.

             //trigger callback in a Thread Pool thread to be able
             // to continue with the next job ASAP
             ThreadPool.QueueUserWorkItem(() => job.Callback(job));

            if (_queue.Count == 0)
              _event.Reset();

        }
    }
}

Answer 3

听起来您需要一个包含 5 个线程的线程池，其中每个线程在完成后放弃硬件并将其添加回某个队列。那行得通吗？如果是这样，.Net 使线程池变得非常容易。

Answer 4

听起来很像Sleeping barber problem。我相信标准的解决方案是使用semaphores