如何在Asp Net Core中重用线程

Question

您好我正在构建一个tcp服务器，我将连接多个客户端，以便向服务器发送和接收数据。

我想知道框架是否未创建 1：1 线程与客户端比率，但使用线程池< / strong>如何发生以下情况：

1 。如果在接受套接字后执行的方法在其中包含一个循环，则不会在客户端上下文中阻止分配的线程（由线程池阻塞？）
2 。每个客户的上下文存储在哪里？

P.S 在我的图片中，我不明白蓝色线程（由线程池提供服务两个客户端）如何被重用。

下面的代码包含Handler（包含所有连接）和Client（套接字包装器，具有基本读/写功能）。

套接字处理程序

  class Handler
            {

                private Dictionary<string, Client> clients = new Dictionary<string, Client>();
                private object Lock = new object();

                public Handler()
                {

                }
                public async Task LoopAsync(WebSocketManager manager)
                {
                    WebSocket clientSocket = await manager.AcceptWebSocketAsync();
                    string clientID = Ext.MakeId();
                    using(Client newClient = Client.Create(clientSocket, clientID))
                    {
                        while (newClient.KeepAlive)
                        {
                            await newClient.ReceiveFromSocketAsync();
                        }

                    }


                }
                public  bool RemoveClient(string ID)
                {
                    bool removed = false;
                    lock (Lock)
                    {
                        if (this.clients.TryGetValue(ID, out Client client))
                        {
                            removed= this.clients.Remove(ID);
                        }
                    }
                    return removed;

                }

            }

SocketWrapper

class Client:IDisposable
    {
        public static Client Create(WebSocket socket,string id)
        {
            return new Client(socket, id);
        }
        private readonly string ID;
        private const int BUFFER_SIZE = 100;


        private readonly byte[] Buffer;
        public bool KeepAlive { get; private set; }
        private readonly WebSocket socket;


        private Client(WebSocket socket,string ID)
        {
            this.socket = socket;
            this.ID = ID;
            this.Buffer = new byte[BUFFER_SIZE];
        }
        public async  Task<ReadOnlyMemory<byte>> ReceiveFromSocketAsync()
        {   
            WebSocketReceiveResult result = await this.socket.ReceiveAsync(this.Buffer, CancellationToken.None);
            this.KeepAlive = result.MessageType==WebSocketMessageType.Close?false:true;
            return this.Buffer.AsMemory();
        }

        public async Task SendToSocketAsync(string message)
        {
            ReadOnlyMemory<byte> memory = Encoding.UTF8.GetBytes(message);
            await this.socket.SendAsync(memory, WebSocketMessageType.Binary,true,CancellationToken.None);
        }

        public void Dispose()
        {
            this.socket.Dispose();
        }
    }

将在应用程序中注入的服务：

class SocketService
    {
        Handler hander;
        public SocketService(Handler _handler)
        {
            this.hander = _handler;
        }
        RequestDelegate next;

        public async Task Invoke(HttpContext context)
        {
            if (!context.WebSockets.IsWebSocketRequest)
            {
                await  this.next(context);
                return;
            }
            await this.hander.AddClientAsync(context.WebSockets);

        }
    }