异步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, 30);
                _server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);
                #endregion

                _server.Blocking = false;
                _server.ExclusiveAddressUse = false;
                _server.Bind(new IPEndPoint(IPAddress.Any, this._port));
                _server.Listen(1000000);
                Parallel.For(0, 1000000, 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, 0, 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 > 0)
                    {
                        var buffer = new byte[ns];

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

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

                        user.ClearReceiveBuffer();

                        buffer = null;

                        remote.BeginReceive(user.ReceiveBuffer, 0, 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, 0, 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("\") + 1),
                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
如果发现本文有什么问题和任何建议，也随时欢迎交流~