Biến ổ cắm async Song song và không chỉ đồng thời trong ứng dụng rất chuyên sâu sử dụng TPL

Question

Tôi đang viết một ứng dụng sử dụng Socket và nó sẽ rất chuyên sâu, sau đó tôi thực sự cần sử dụng mọi lõi trong máy chủ lớn. Tôi thấy câu hỏi (how to using ThreadPool to run socket thread parallel?) ở đây trong stackoverflow chỉ có một câu trả lời trỏ đến điều này MSDN Sample.

Nhưng tôi nghĩ rằng nó chỉ duy nhất làm thế nào để làm cho nó đồng thời và không Parallel, đây là một người nào đó hỏi How cpu intensive is opening a socket và ngoại hình của nó rất đặc biệt, một người nào đó ở đây tell dont nó giúp TPL TaskFactory.FromAsync vs Tasks with blocking methods và ai đó dạy làm thế nào để làm điều đó ở đây whith TaskFactory.FromAsync (Is there a pattern for wrapping existing BeginXXX/EndXXX async methods into async tasks?).

Làm thế nào tôi có thể duy trì hoạt động của ổ cắm song song và thực hiện và nếu các vấn đề như ngắt kết nối, một nửa ổ cắm kết nối và ranh giới thông báo là nhức đầu theo cách không đồng bộ bình thường. Làm thế nào để đối phó với nó nếu nó đặt cùng TPL và nhiệm vụ.

Answer 1

Xem liên kết này về TPL and Traditional .NET Asynchronous Programming, nó không trả lời nhưng có thể có thể giúp bạn. Cả những thông tin về Asynchronous Programming Model (APM) và mẫu không đồng bộ tổ chức sự kiện có trụ sở (EAP)

Answer 2

thấy rằng:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Net; 
using System.Net.Sockets; 
using System.Text; 
using System.Threading; 
using System.Threading.Tasks; 

namespace skttool 
{ 
    public class StateObject 
    { 
     public Socket workSocket = null; 
     public const int BufferSize = 1024; 
     public byte[] buffer = new byte[BufferSize]; 
     public int bytesRead = 0; 
     public StringBuilder sb = new StringBuilder(); 
    } 

    public class tool 
    { 
     //------------------------------------------------- 
     private ManualResetEvent evtConnectionDone = new ManualResetEvent(false); 
     private Socket skttool = null; 
     private bool running = false; 
     private StateObject state = null; 
     //------------------------------------------------- 
     toolConfig _cfg; 
     public tool(toolConfig cfg) 
     { 
      _cfg = cfg; 
     } 
     //------------------------------------------------- 
     public void socketListeningSet() 
     { 
      IPEndPoint localEndPoint; 
      Socket skttool; 
      byte[] bytes = new Byte[1024]; 
      localEndPoint = new IPEndPoint(IPAddress.Any, _cfg.addressPort); 
      skttool = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 
      skttool.Bind(localEndPoint); 
      skttool.Listen(_cfg.maxQtdSockets); 
     } 
     //------------------------------------------------- 
     public void start() 
     { 
      running = true; 
      Task T1 = Task.Factory.StartNew(socketListeningSet); 
      T1.ContinueWith(prev => 
      { 
       while (running) 
       { 
        evtConnectionDone.Reset(); 
        Task<Socket> accepetChunk = Task<Socket>.Factory.FromAsync(
                     skttool.BeginAccept, 
                     skttool.EndAccept, 
                     accept, 
                     skttool, 
                     TaskCreationOptions.AttachedToParent); 
        accepetChunk.ContinueWith(accept, TaskContinuationOptions.NotOnFaulted | TaskCreationOptions.AttachedToParent); 
        evtConnectionDone.WaitOne(); 
       } 
      }); 
     } 
     //------------------------------------------------- 
     void accept(Task<Socket> accepetChunk) 
     { 
      state = new StateObject(); 
      evtConnectionDone.Set(); 
      state.workSocket = accepetChunk.Result; 
      Task<int> readChunk = Task<int>.Factory.FromAsync(
                 state.workSocket.BeginReceive, 
                 state.workSocket.EndReceive, 
                 state.buffer, 
                 state.bytesRead, 
                 state.buffer.Length - state.bytesRead, 
                 null, 
                 TaskCreationOptions.AttachedToParent); 
      readChunk.ContinueWith(read, TaskContinuationOptions.NotOnFaulted | TaskCreationOptions.AttachedToParent); 
     } 
     //------------------------------------------------- 
     void read(Task<int> readChunk) 
     { 
      state.bytesRead += readChunk.Result; 
      if (readChunk.Result > 0 && state.bytesRead < state.buffer.Length) 
      { 
       read(); 
       return; 
      } 
      _data = doTask(_data); 
      Task<int> sendChunk = Task<int>.Factory.FromAsync(
                 state.workSocket.BeginSend, 
                 state.workSocket.EndSend, 
                 state.buffer, 
                 state.bytesRead, 
                 state.buffer.Length - state.bytesRead, 
                 null, 
                 TaskCreationOptions.AttachedToParent); 
      sendChunk.ContinueWith(send, TaskContinuationOptions.NotOnFaulted | TaskCreationOptions.AttachedToParent); 
     } 
     //------------------------------------------------- 
     void send(Task<int> readChunk) 
     { 
      state.workSocket.Shutdown(SocketShutdown.Both); 
      state.workSocket.Close(); 
     } 
     //------------------------------------------------- 
     byte[] doTask(byte[] data) 
     { 
      return Array.Reverse(data); 
     } 
     //------------------------------------------------- 
    } 
}