异步tcp通信——APM.Core 服务端概述

为什么使用异步

　　异步线程是由线程池负责管理，而多线程，我们可以自己控制，当然在多线程中我们也可以使用线程池。就拿网络扒虫而言，如果使用异步模式去实现，它使用线程池进行管理。异步操作执行时，会将操作丢给线程池中的某个工作线程来完成。当开始I/O操作的时候，异步会将工作线程还给线程池，这意味着获取网页的工作不会再占用任何CPU资源了。直到异步完成，即获取网页完毕，异步才会通过回调的方式通知线程池。可见，异步模式借助于线程池，极大地节约了CPU的资源。
　　注：DMA（Direct Memory Access）直接内存存取，顾名思义DMA功能就是让设备可以绕过处理器，直接由内存来读取资料。通过直接内存访问的数据交换几乎可以不损耗CPU的资源。在硬件中，硬盘、网卡、声卡、显卡等都有直接内存访问功能。异步编程模型就是让我们充分利用硬件的直接内存访问功能来释放CPU的压力。
　　两者的应用场景：
　　　　计算密集型工作，采用多线程。
　　　　IO密集型工作，采用异步机制。

C#中实现异步tcp通信

　　socket中仅仅需要将Blocking=false即可轻松实现异步，部分示例如下：

 /// <summary>
         /// 启动tcp监听
         /// </summary>
         public void Start()
         {
             if (!_isStarted)
             {
                 _isStarted = true;
                 _server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                 #region socket配置
                 LingerOption lingerOption = new LingerOption(true, );
                 _server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
                 #endregion

                 _server.Blocking = false;
                 _server.ExclusiveAddressUse = false;
                 _server.Bind(new IPEndPoint(IPAddress.Any, this._port));
                 _server.Listen();
                 Parallel.For(, , i =>
                 {
                     _server.BeginAccept(new AsyncCallback(ProcessAccept), _server);
                 });
             }
         }

　　tcp异步中处理接io操作最关键的参数：IAsyncResult，使用一般用begin开始，end结束。

　　接收数据处理如下：

 /// <summary>
         /// 处理传入的连接请求
         /// </summary>
         private void ProcessAccept(IAsyncResult ar)
         {
             var s = (Socket)ar.AsyncState;
             var remote = s.EndAccept(ar);
             var user = new UserToken(this._maxBufferSize) { ID = remote.RemoteEndPoint.ToString(), Client = remote };
             remote.BeginReceive(user.ReceiveBuffer, , user.ReceiveBuffer.Length, SocketFlags.None, new AsyncCallback(ProcessReceive),
                 user);
             s.BeginAccept(new AsyncCallback(ProcessAccept), s);
         }

 private void ProcessReceive(IAsyncResult ar)
         {
             var user = (UserToken)ar.AsyncState;
             var remote = user.Client;
             try
             {
                 if (remote.Connected)
                 {
                     var ns = remote.EndReceive(ar);

                     if (ns > )
                     {
                         var buffer = new byte[ns];

                         Buffer.BlockCopy(user.ReceiveBuffer, , buffer, , buffer.Length);

                         user.UnPackage(buffer, (p) =>
                         {
                             Interlocked.Increment(ref this._receiveCount);
                             this.RaiseOnOnReceived(user, p);
                         });

                         user.ClearReceiveBuffer();

                         buffer = null;

                         remote.BeginReceive(user.ReceiveBuffer, , user.ReceiveBuffer.Length, SocketFlags.None, new AsyncCallback(ProcessReceive), user);
                     }
                 }
                 else
                 {
                     this.RaiseOnDisConnected(user, new Exception("客户端已断开连接"));
                     this.CloseClient(user);
                 }
             }
             catch (SocketException sex)
             {
                 this.RaiseOnDisConnected(user, sex);
                 this.CloseClient(user);
             }
             catch (Exception ex)
             {
                 this.RaiseOnError(user, ex);
                 this.CloseClient(user);
             }
         }

　　发送数据处理如下：

 /// <summary>
         /// 发送信息
         /// </summary>
         /// <param name="remote"></param>
         /// <param name="data"></param>
         /// <param name="type"></param>
         /// <param name="auth"></param>
         private void SendAsync(UserToken remote, byte[] data, TransportType type = TransportType.Heart)
         {
             try
             {
                 using (var pakage = new TcpPackage(data, type, remote.Auth))
                 {
                     remote.Client.BeginSend(pakage.Data, , pakage.Data.Length, SocketFlags.None, new AsyncCallback(EndSend), remote);
                 }

             }
             catch (SocketException sex)
             {
                 this.RaiseOnDisConnected(remote, sex);
             }
             catch (Exception ex)
             {
                 this.RaiseOnError(remote, ex);
             }
         }

 private void EndSend(IAsyncResult ar)
         {
             var remote = (UserToken)ar.AsyncState;
             remote.Client.EndSend(ar);
             Interlocked.Increment(ref this._sendCount);
         }

　　心跳、消息、文件等逻辑都可以基于发送逻辑来完成

 /// <summary>
         /// 回复心跳
         /// </summary>
         /// <param name="remote"></param>
         /// <param name="package"></param>
         private void ReplyHeart(UserToken remote, TcpPackage package)
         {
             this.SendAsync(remote, null, TransportType.Heart);
         }

 /// <summary>
         /// 发送信息
         /// </summary>
         /// <param name="remote"></param>
         /// <param name="msg"></param>
         public void SendMsg(UserToken remote, byte[] msg)
         {
             this.SendAsync(remote, msg, TransportType.Message);
         }

 /// <summary>
         /// 发送文件
         /// </summary>
         /// <param name="remote"></param>
         /// <param name="filePath"></param>
         public void SendFile(UserToken remote, string filePath)
         {
             using (var file = new TransferFileInfo()
             {
                 ID = remote.ID,
                 FileBytes = File.ReadAllBytes(filePath),
                 Name = filePath.Substring(filePath.LastIndexOf("\\") + ),
                 CreateTime = DateTime.Now.Ticks
             })
             {
                 var buffer = TransferFileInfo.Serialize(file);
                 this.SendAsync(remote, buffer, TransportType.File);
                 buffer = null;
             }
         }

 /// <summary>
         /// 发送文件
         /// </summary>
         /// <param name="remote"></param>
         /// <param name="fileName"></param>
         /// <param name="file"></param>
         public void SendFile(UserToken remote, string fileName, byte[] file)
         {
             using (var fileInfo = new TransferFileInfo()
             {
                 ID = remote.ID,
                 FileBytes = file,
                 Name = fileName,
                 CreateTime = DateTime.Now.Ticks
             })
             {
                 var buffer = TransferFileInfo.Serialize(fileInfo);
                 this.SendAsync(remote, buffer, TransportType.File);
                 buffer = null;
             }
         }

异步tcp通信——APM.Core 服务端概述

异步tcp通信——APM.Core 解包

异步tcp通信——APM.Server 消息推送服务的实现

异步tcp通信——APM.ConsoleDemo

转载请标明本文来源：http://www.cnblogs.com/yswenli/
更多内容欢迎star作者的github：https://github.com/yswenli/APM
如果发现本文有什么问题和任何建议，也随时欢迎交流~