Socket编程基础 之 异步编程

.Net Socket编程基础 异步编程  同步socket并发性很差，特别是对于服务器端来说，要处理很多客户端连接，同步Socket力不从心，要提高系统的并发处理能力，就要借助.Net异步编程模式。  .Net Socket的异步编程模式和.Net 通用的APM编程模式是一致的，调用BeginXXX方法开始异步操作，系统系统处理完成后调用回调函数，在回调函数中调用EndXXX结束操作。  常用的Socket对象的异步API有 接受客户端连接 BeginAccept, EndAccept 接收数据 BeginReceive, EndReceive 发送数据 BeginSend, EndSend  下面是简单的Socket服务端实现的部分，演示Socket异步API的使用。  首先New一个Socket对象，绑定到特定端口，开始监听客户端发来的连接请求。  

01 <span style="font-size: 10pt;">Socket socket;
02 socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
03 socket.Bind(new IPEndPoint(address, port));
04 socket.Listen(backlog);
05 // backlog 参数指定队列中最多可容纳的等待接受的传入连接数，不同操作系统的backlog参数的上限是不一样的
06
07 //然后调用BeginAccept开始等待客户端连接。
08 while (true)
09 {
10     acceptDone.Reset();
11     socket.BeginAccept(new AsyncCallback(AcceptCallback), socket);
12     acceptDone.WaitOne();
13 }
14
15 //acceptDone是信号量
16 private ManualResetEvent acceptDone = new ManualResetEvent(false);
17
18 //AcceptCallback是回调函数，下面是这个函数的部分代码
19
20 private void AcceptCallback(IAsyncResult ar)
21 {
22     acceptDone.Set();
23     // EndAccept 将会返回Windows自动分配的 Socket 对象实例
24    Socket handler = listener.EndAccept(ar);
25     log.InfoFormat("{0} connected", handler.RemoteEndPoint.ToString());
26
27     //可以限制允许的最大连接数连接，保存当前对话的session信息等
28    SocketState state = new SocketState(handler);
29     SocketError errorCode;
30     handler.BeginReceive(state.Buffer, 0, state.BufferSize, SocketFlags.None, out errorCode, new AsyncCallback(ReceiveCallback), state);
31
32     if ((errorCode != SocketError.Success) && (errorCode != SocketError.IOPending))
33     {
34         ProcessError(handler, errorCode, "BeginReceive");
35     }
36 }
37 </span>

BeginXXX的重载列表中一般有一个函数重载允许你传一个SocketError 类型的out参数，可以根据这个参数判断是否出错。  SocketState对象是为了方便写代码构造的用来保存当前Socket状态的类，比如上次接受数据是什么时间，一共接受了多少数据等。  

1 <span style="font-size: 10pt;">public class SocketState : IDisposable
2 {
3 private Socket socket = null;
4 private const int bufferSize = 1024;
5 private byte[] buffer = new byte[bufferSize];
6     。。。
7 }
8 </span>

操作系统接受到数据后会调用回调函数ReceiveCallback   private void ReceiveCallback(IAsyncResult ar) {     SocketState state = (SocketState)ar.AsyncState;     Socket handler = state.Socket;      int bytesRead = handler.EndReceive(ar); 	     if (bytesRead > 0)     {        //处理接受的数据         。。。         //如果还有数据，继续接受         if (handler.Available > 0 || handler.Connected )           {               SocketError errorCode;               handler.BeginReceive(state.Buffer, 0, state.BufferSize, SocketFlags.None, out errorCode, new AsyncCallback(ReceiveCallback), state);          }          else         {             handler.Close();             //其他处理代码，比如重置连接计数器等       }      } } 

上面代码只是简单介绍API的用法，很多地方没有考虑，完整的Socket服务代码比这个要复杂得多。  BeginXXX、EndXXX这种异步模式比同步方式要高效得多，但是每次需要New一个IAsyncResult对象和state对象，并发高的情况下对GC也是不小的压力，频繁的申请、释放小块内存，容易产生很多小的内存碎片，内存碎片多的话内存利用率低，而且可能出现即使内存没有全部用完，但是.Net Runtime还是会报告没有可分配的内存的情况。另一方便，编程模型比较复杂。  为了进一步简化Socket异步编程，.Net3.5引入了新的编程模型。

 .Net 3.x 的Socket异步编程  在.Net 3.5中引入了一组增强功能，提供可供专用的高性能套接字应用程序使用的可选异步模式，并且简化了Socket异步编程复杂度。SocketAsyncEventArgs类是这组增强功能中最常用的一个类，专为需要高性能的网络服务器应用程序而设计。它主要的成员如下：  OnCompleted事件：在异步操作完成后，系统会触发OnCompleted事件，在事件处理代码中可以进行后续异步套接字操作的处理。 SetBuffer方法：初始化要用于异步套接字方法的数据缓冲区。从上面的一些例子可以看到，不管同步还是异步，都需要一个缓冲数组来接受数据，使用SetBuffer可以简化缓冲区的设置。 LastOperation属性：获取最近使用此上下文对象执行的套接字操作类型。Accept、Receive、Send都可以用SocketAsyncEventArgs类，需要通过这个属性来判断上次进行的是什么操作。 SocketError：异步套接字操作的结果， SocketError.Success 表示操作成功完成  .Net 3.X这些Socket增强功能的主要特点是可以避免在异步套接字 I/O 量非常大时发生重复的对象分配和同步，怎么实现呢？就是利用很通用的对象缓冲池技术。  一般需要对两类对象使用对象池，一个对象池存放SocketAsyncEventArgs对象实例，一个对象池存放缓存byte[]实例，每次需要SocketAsyncEventArgs对象或者缓存数组时，就从对象池中取一个，用完了再放回对象池。对象池方式管理分配的对象属于通用的高效内存使用方式，不是Socket编程特有的模式。  这两个对象池实现的例子可以参考MSDN上的示例代码。 	 使用此组执行异步套接字操作的模式包含以下步骤：(来自MSDN) 1.分配一个新的 SocketAsyncEventArgs 上下文对象，或者从应用程序池中获取一个空闲的此类对象。 2.将该上下文对象的属性设置为要执行的操作（例如，完成回调方法、数据缓冲区、缓冲区偏移量以及要传输的最大数据量）。 3.调用适当的套接字方法 (xxxAsync) 以启动异步操作。 4.如果异步套接字方法 (xxxAsync) 返回 true，则在回调中查询上下文属性来获取完成状态。 5.如果异步套接字方法 (xxxAsync) 返回 false，则说明操作是同步完成的。可以查询上下文属性来获取操作结果。 6.将该上下文重用于另一个操作，将它放回到应用程序池中，或者将它丢弃。  用代码来说明更直接一些，我们来改写上面的例子  

01 <span style="font-size: 10pt;">//创建Socket对象，开始监听
02 //创建Accept用的SocketAsyncEventArgs对象实例，指定事件处理函数
03 SocketAsyncEventArgs  acceptArgs = new SocketAsyncEventArgs();
04 acceptArgs.Completed += Process_Accept;
05
06 //开始等待客户端的连接
07 if (!socket.AcceptAsync(e))
08 {
09     Process_Accept(this, e);
10 }
11
12 //在事件处理函数Process_Accept中
13 ///。。。
14
15 //继续等待其他客户端连接
16 Socket acceptSocket = e.AcceptSocket;
17 StartAccept(e);
18
19 //开始异步接收数据
20 SocketAsyncEventArgs  socketReceiveArgs = new SocketAsyncEventArgs();
21 socketReceiveArgs.Completed += Process_Receive;
22 socketReceiveArgs.SetBuffer(receiveBuffer, 0, bufferSize);
23 if (!socket.ReceiveAsync(socketReceiveArgs))
24 {
25     Process_Receive(this, socketReceiveArgs);
26 }
27
28 //在事件处理函数Process_Receive中处理接收到的数据
29
30 if (e.SocketError == SocketError.Success)
31 {
32     if (e.BytesTransferred > 0)
33     {
34         byte[] data = new byte[e.BytesTransferred];
35         Buffer.BlockCopy(e.Buffer, e.Offset, data, 0, e.BytesTransferred);
36         //处理数据
37       。。。
38       //继续接受数据
39       socketReceiveArgs.SetBuffer(receiveBuffer, 0, bufferSize);
40         if (!socket.ReceiveAsync(socketReceiveArgs))
41         {
42              Process_Receive(this, socketReceiveArgs);
43         }
44     }
45     else
46     {
47         //关闭连接
48     }
49 }
50 else
51 {
52     //错误处理
53 }