平行的.重I/O操作中的ForEach与异步Forloop

我想比较两种理论情景。为了解决这个问题，我简化了这些例子。但基本上这是典型的生产者和消费者场景。(我关注的是消费者)。

我有一个大的Queue<string> dataQueue，我必须传输到多个客户端。

让我们从简单的例子开始:

 class SequentialBlockingCase
 {
    public static Queue<string> DataQueue = new Queue<string>();
    private static List<string> _destinations = new List<string>();
    /// <summary>
    /// Is the main function that is run in its own thread
    /// </summary>
    private static void Run()
    {
        while (true)
        {
            if (DataQueue.Count > 0)
            {
                string data = DataQueue.Dequeue();
                foreach (var destination in _destinations)
                {
                    SendDataToDestination(destination, data);
                }
            }
            else
            {
                Thread.Sleep(1);
            }
        }
    }
    private static void SendDataToDestination(string destination, string data)
    {
        //TODO: Send data using http post, instead simulate the send
        Thread.Sleep(200);
    }
}
}

现在这个设置工作得很好。它坐在那里轮询Queue，当有数据要发送时，它将其发送到所有目的地。

问题:

• 如果其中一个目的地不可用或缓慢，它会影响所有其他目的地。
• 在并行执行的情况下不使用多线程
• 阻塞到每个目的地的每次传输。

这是我的第二次尝试:

 class ParalleBlockingCase
{
    public static Queue<string> DataQueue = new Queue<string>();
    private static List<string> _destinations = new List<string>();
    /// <summary>
    /// Is the main function that is run in its own thread
    /// </summary>
    private static void Run()
    {
        while (true)
        {
            if (DataQueue.Count > 0)
            {
                string data = DataQueue.Dequeue();
                Parallel.ForEach(_destinations, destination =>
                {
                    SendDataToDestination(destination, data);
                });
            }
            else
            {
                Thread.Sleep(1);
            }
        }
    }
    private static void SendDataToDestination(string destination, string data)
    {
        //TODO: Send data using http post
        Thread.Sleep(200);
    }
}

如果一个目的地速度慢或不可用，此修订至少不会影响其他目的地。

然而，这种方法仍然阻塞，我不确定Parallel.ForEach是否使用线程池。我的理解是，它将创建X数量的线程/任务，并一次执行4(4核cpu)。但是它必须在任务5开始之前完成任务1。

因此我的第三个选择:

class ParalleAsyncCase
{
    public static Queue<string> DataQueue = new Queue<string>();
    private static List<string> _destinations = new List<string> { };
    /// <summary>
    /// Is the main function that is run in its own thread
    /// </summary>
    private static void Run()
    {
        while (true)
        {
            if (DataQueue.Count > 0)
            {
                string data = DataQueue.Dequeue();
                List<Task> tasks = new List<Task>();
                foreach (var destination in _destinations)
                {
                    var task = SendDataToDestination(destination, data);
                    task.Start();
                    tasks.Add(task);
                }
                //Wait for all tasks to complete
                Task.WaitAll(tasks.ToArray());
            }
            else
            {
                Thread.Sleep(1);
            }
        }
    }
    private static async Task SendDataToDestination(string destination, string data)
    {
        //TODO: Send data using http post
        await Task.Delay(200);
    }
}

现在从我对这个选项的理解来看，仍然会阻塞在Task.WaitAll(tasks.ToArray());的主线程上，这很好，因为我不想让它跑掉创建任务的速度比它们可以执行的速度快。

但是并行执行的任务应该使用ThreadPool，并且所有X个数的任务应该同时开始执行，而不是阻塞或按顺序执行。(线程池将在它们变为活动状态或awaiting时在它们之间交换)

现在是我的问题。

选项3是否比选项2有性能优势?

特别是在性能更高的服务器端场景中。在我正在开发的具体软件中。上面的简单用例可能有多个实例。有几个消费者。

我对这两种解决方案的理论差异和优缺点很感兴趣，如果有的话，甚至可能有更好的第四个选择。