异步生产者-消费者是否有助于在整个程序期间不窃取线程？

Question

下面的代码从 tcp 接收消息并将它们传递给适当的消息处理程序。 根据消息类型，消息处理程序可能需要几分钟或几秒钟来处理它。

我选择了为每种消息类型设置单独的处理程序的设计。 但是，现在我在想：

1. 即使我有异步生产者-消费者（ await _messages.Reader.WaitToReadAsync() ），我仍然有Task.Run每个消息处理程序都有一个循环，这意味着它将在整个程序的持续时间内从线程池中保留整个线程，正确的？ 所以，如果我有 3 个消息处理程序，我就持有线程池中的 3 个线程，对吗？
2. 在代码当前实现的方式中使用异步生产者-消费者有什么好处吗？ 同样，由于每个消息处理程序都在整个程序的持续时间内启动Task.Run ，我认为这没有任何好处，我通常只能使用像BlockingCollection这样的同步集合，对吗？
3. 这样做的更好方法是什么？ 我是否应该只有一个带有单个Task.Run的消息处理程序，它有一个循环并检查新消息，它会产生其他Task.Run以进行新的按摩？ 但是，我需要一种方法来等待上一个任务完成，而不是阻止检查新消息。 也许我应该有一些可取消的执行任务，这样我就可以取消之前的任务并为相同的消息类型启动一个新任务？

代码

    public class Distributor
    {
        private readonly Dictionary<string, MessageHandler> _messageHandlers;

        public void StartReceive()
        {
              // tcpClient PSEUDO CODE
              while (_tcpClient.NewMessageAvailable)
              { 
                  var data = _tcpClient.GetNewMessage();

                  _messageHandlers[data.MsgType].Add(data.Data);
              }
        }
 
        private void RegisterMessageHandlers()
        {
            _messageHandlers["msgType1"] = new MyMessageHandler1(...);
            _messageHandlers["msgType2"] = new MyMessageHandler2(...);
            _messageHandlers["msgType3"] = new MyMessageHandler3(...);
           ...
        }
    }

    public abstract class MessageHandler
    {
        private readonly Channel<string> _messages;

        public MessageHandler()
        {
           _messages = Channel.CreateBounded<int>(new BoundedChannelOptions(1)
           {
              SingleReader = true,
              SingleWriter = true,
              FullMode = BoundedChannelFullMode.DropOldest,
           });
        }

        public void Start()
        {
            _task = Task.Run(async () =>
            {
                try
                {                        
                     while (await _messages.Reader.WaitToReadAsync())
                     {
                         try
                         {
                             _messages.Reader.TryRead(out var msg);
                             await Task.Run(async () => await HandleAsync(msg));
                         }
                         catch (Exception ex)
                         {
                         }
                     }
                }
                catch { } // OperationCanceledException
            }
        }
    
        public void Add(string msg)
        {
            _messages.Writer.TryWrite(msg);
        }

        protected abstract Task HandleAsync(string msg);
    }
    
    public class MyMessageHandler1 : MessageHandler
    {        
        protected override async Task HandleAsync(string msg)
        {
           // DO SOME LONG WORK        
            await _service1.DoWork();
        }       
    }  

    public class MyMessageHandler2 : MessageHandler
    {        
        protected override async Task HandleAsync(string msg)
        {
           // DO SOME WORK        
            await _service2.DoWork();
        }       
    }       

Answer 1

我仍然有Task.Run ，每个消息处理程序都有一个循环，这意味着它将在整个程序的持续时间内保持线程池中的整个线程，对吗？ 所以，如果我有 3 个消息处理程序，我就持有线程池中的 3 个线程，对吗？

我只会回答这个问题。 你的假设是错误的。 您正在使用带有异步委托的Task.Run ：

_task = Task.Run(async () =>
{
    while (await _messages.Reader.WaitToReadAsync())
    {
        //...
    }
}

_task从开始到结束都不是在单个线程上运行，除非委托中的所有await ing 都发生在已完成的可等待对象上，这是不太可能的。 最初， ThreadPool线程用于调用_messages.Reader.WaitToReadAsync方法，当该方法返回时，该线程被释放回ThreadPool 。 在await期间不涉及 任何线程，并且在每次await之后，不同的线程可能会继续运行直到下一个await 。

从理论上讲，您可以同时运行数千个类似于_task的任务，而只使用少数几个线程。 任务/线程的比率取决于循环内有多少工作是同步的，有多少是异步的。

要更好地理解Task.Run作为一种机制，请务必阅读 Stephen Toub 的这篇文章： Task.Run vs Task.Factory.StartNew 。