几种Socket服务器模型比较!
来源:互联网 发布:ip地址转网络字节序 编辑:程序博客网 时间:2024/05/20 10:22
一、异步BeginXXX,EndXXX
先看其实现的方式:
1.监听
//开启监听线程 public void StartListenThread() { Thread listen_thread = new Thread(new ThreadStart(ListenThread)); listen_thread.Start(); } public void ListenThread() { try { listener = new TcpListener(System.Net.IPAddress.Parse(地址),Convert.ToInt32(端口)); listener.Start(); while (IsLoopContinue) { waithandle.Reset(); listener.BeginAcceptTcpClient(new AsyncCallback(ListenCallBack), listener); waithandle.WaitOne();//用以同步异步接受连接的请求 } } catch { IsLoopContinue = false; } }2.Accept回调
//异步接受连接回调函数 public void ListenCallBack(IAsyncResult ar) { try { TcpListener mylistener = ar.AsyncState as TcpListener; TcpClient client = mylistener.EndAcceptTcpClient(ar); SocketStruct newclient = new SocketStruct(client);//封装socket waithandle.Set();//接受下一个连接 newclient._nws.BeginRead(newclient._readbt, 0, newclient._readbt.Length, new AsyncCallback(ReadCallBack), newclient);//首次读取 } catch { // } }在accepet回调中才可获取时间完成后的信息,在异步accept完成后将得到新客户端socket,这时可以利用自定义的小型类去封装socket,该类可以包括该socket,端口,ip,流,缓冲区等等信息,或者其他有关业务的字段。并在首次获取客户端时进行第一次异步读取。异步读取时可以传入供socket操作的缓冲区,以及一个object对象,该对象原本只需传入一个socket对象即可,但是为了与业务交互,将自定义的小型类的实例newclient传入是再好不过了。
3.异步读的回调
//异步读取数据回调函数 public void ReadCallBack(IAsyncResult ar) { try { SocketStruct client = (SocketStruct)ar.AsyncState; int count = client._nws.EndRead(ar); if (count == 0) { //处理客户端正常断开 } else { //客户端有数据,此时可以在缓冲区找到传来的数据 if (IsLoopContinue)//只有监听线程存在,则继续读取 { //递归死循环 client.InitReadBt(); client._nws.BeginRead(client._readbt, 0, client._readbt.Length, ReadCallBack, client); } } } catch { } }异步完成后则进入回调,在回调信息里最重要的就是EndRead后返回的字节数了,返回0则代表响应了一次I/0断开事件。这个0字节绝对不代表发送空数据,因为任何所谓的"空"数据都不是0字节,这个0字节是socket底层的一个返回值,可以有效的提示客户端断开。若大于0,则表明这次事件成功的读取到了数据,则可以递归进行下次读取。
4.异步发送和异步发送回调
发送 client._nws.BeginWrite(缓冲区, 0, count, SendCallBack, client);
回调 public void SendCallBack(IAsyncResult ar)
{
SocketStruct ss = ar.AsyncState as SocketStruct;
ss._nws.EndWrite(ar);
}
异步发送的回调没什么太多的信息,主要作用是看发送成功没。
总结:
这种方式主要利用递归生成while(true)来实现循环监听和读取。其中读取和发送均是利用socket中的流的异步读与写,每次读写均需要传入一个buffer,每个动作都有一个对应的完成事件,颇有IOCP的影子,至于是否支持大量客户端暂时不清楚,因为这种BeginXXX的操作到底是哪种线程类型,资源消耗如何还值得研究,但必须肯定的是绝对比new Thread这种方式要省资源和高效的多。
二、Select模型
为了方便select的实现,需要自定义一个列表,该列表需要具有线程安全级别
public class ListHandler<T> { public List<T> list; public ListHandler() { list=new List<T>(); } public void Add(T value) { lock (list) { list.Add(value); } } public void Remove(T value) { lock (list) { list.Remove(value); } } public List<T> ToList() { lock (list) { return list.ToList(); } } public T Find(Predicate<T> match) { lock (list) { return list.Find(match); } } }其实也不需要一个泛型类,因为T肯定是用来存放socket类型的,当然,为了扩展,也可将封装socket的小型类做为T
在开始程序之前定义好该列表对象:
/// <summary> /// 客户端Socket列表 /// </summary> private ListHandler<Socket> socketList;
select模型代码实现如下:
/// <summary> /// 监听线程 /// </summary> public void StartListenThread() { try { listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); listener.Bind( new IPEndPoint(IPAddress.Parse(readXML.GetIp()), Convert.ToInt32(readXML.GetPort())) ); listener.Listen(10); socketList.Add(listener); while (true) { List<Socket> checkReadList = socketList.ToList(); Socket.Select(checkReadList, null, null, 1000); int count = checkReadList.Count; if (count > 0) { sb = "有数据的客户端个数为:" + count.ToString(); Console.WriteLine(sb); for (int i = 0; i < count; i++) { if (checkReadList[i].Equals(listener)) { listener.BeginAccept(new AsyncCallback(ListenCallBack), listener); } else { SocketStruct ss = clientInfoList.Find(s => s._socketClient == checkReadList[i]); checkReadList[i].BeginReceive(buffer.totalBytes, ss._offset, BUFFERSIZE, 0, new AsyncCallback(ReceiveCallBack), ss); } } } } } catch { } }我想这几十行代码再霸气不过了,listen、accept、receive几个动作一气呵成,感觉直接就把服务器代码写完了。先来看下MSDN的解释:
Select 是一种静态方法,它可确定一个或多个 Socket 实例的状态。必须先将一个或多个套接字放入 IList 中,然后才能使用 Select 方法。通过调用 Select(将 IList 作为 checkRead 参数),可检查是否具有可读性。若要检查套接字是否具有可写性,请使用 checkWrite 参数。若要检测错误条件,请使用 checkError。在调用 Select 之后,IList 中将仅填充那些满足条件的套接字。
如果当前处于侦听状态,则可读意味着可成功地对 Accept 进行调用而没有阻止。如果当前已接受连接,则可读意味着有可读取的数据。这些情况下,所有的接收操作均可成功进行而没有阻止。可读性也可指示远程 Socket 是否已经关闭连接;如果连接已关闭,则对 Receive 的调用将立即返回,并返回零字节。
如果至少一个相关套接字(checkRead、checkWrite 和 checkError 列表中的套接字)符合其指定的条件,或者超过 microSeconds 参数,则无论先出现其中哪种情况,都会返回 Select。将microSeconds 设置为 -1 会指定无限大的超时值。
如果对 Connect 进行非阻止调用,则可写意味着已经成功连接。如果已经建立连接,则可写性意味着所有的发送操作均会成功完成而没有阻止。
如果对 Connect 进行非阻止调用,则 checkerror 参数将标识尚未成功连接的套接字。
如果只想确定单个 Socket 的状态,请使用 Poll 方法。
针对MSDN的详细解释,代码如此实现:
1.建立listensocket并且将其加入列表socketList;
2.调用Socket.Select方法
参数:
// checkRead:
// 要检查可读性的 System.Net.Sockets.Socket 实例的 System.Collections.IList。
//
// checkWrite:
// 一个 System.Net.Sockets.Socket 实例的 System.Collections.IList,用于检查可写性。
//
// checkError:
// 要检查错误的 System.Net.Sockets.Socket 实例的 System.Collections.IList。
//
// microSeconds:
// 超时值(以毫秒为单位)。A -1 值指示超时值为无限大。
在这里只需要找出有数据的socket即可,因此第二和三个参数均为null,超时设为1秒
此时列表中只有一个对象,其实就相当于Socket.Poll
3.判断数据的来源
注意Select的时候是将第一个参数中的对象做为check对象,即检查对象,去检测其是否有数据,方法执行完后会把所有符合条件的对象填充到第一个参数里,
所以第一个参数在执行完后肯定是多个对象的列表了。
对于监听socket,它有数据的情况只可能是有了新客户端,此时可以进行异步Accept,并且添加回调
/// <summary> /// 异步接受连接回调函数 /// </summary> /// <param name="ia"></param> public void ListenCallBack(IAsyncResult ia) { Socket listener = (Socket)ia.AsyncState; Socket newClient = listener.EndAccept(ia); socketList.Add(newClient); }
新客户端加入列表后,对于下次的Select操作,第一个参数将不再是列表cout为1的lisent对象了,而是有listensocket和客户端socket,所以若非listensocket产生了数据,
则一定是有数据从客户端发送过来了,立刻进行接收操作,并且回调
/// <summary> /// 异步接收数据回调函数 /// </summary> /// <param name="ia"></param> public void ReceiveCallBack(IAsyncResult ia) { SocketStruct ss = (SocketStruct)ia.AsyncState; Socket newClient = ss._socketClient; int endLength = newClient.EndReceive(ia); Console.WriteLine("读到的字节数:"+endLength.ToString()); if (endLength > 0) { //在此处读取数据 } //the client has disconnected else { try { ss._socketClient.Shutdown(SocketShutdown.Send); } catch(Exception e) { Console.WriteLine(e.Message); } ss._socketClient.Close(); socketList.Remove(ss._socketClient);//维护列表 } }
若要发送数据,则在Select中设置检查可写操作即可筛选多个可发送的socket.
总结:
Select可以同时筛选出多个可读可写的对象,可以批量操作,对于某个时间段具有高并发的场合应该比较适合(没测过),我并没有选用它的原因是批量处理是它的优点也是缺点----由于它的这个超时时间的参数将导致若有客户端断开,则将在超时时间内不停的响应I/0,在这块儿的处理比较棘手,而且若一次筛选出很多有数据的对象,一般在服务器都要有很多业务处理,则可能会导致有些延迟的效果,暂时没有好的解决办法,于是换了另一种方式。不过它在批量筛选上确实很诱人,在某种特殊的场合一定有它的发挥之处。光看实现的方式就觉得很霸气了呢。
三、利用SocketAsyncEventArgs
对于SocketAsyncEventArgs在不用细说了,太多经典的代码和服务器算法模型均出自该类下的socket通信,这种方式虽然我不能去查证其是否用的是IOCP,但是个人认为应该是的,BeginXXX+回调的方式已经有一些完成事件的影子了,而SocketAsyncEventArgs又对每个对象进行了socket操作的封装。就拿MSDN上给出的例子来说这个SocketAsyncEventArgs实现的过程吧。
使用此类执行异步套接字操作的模式包含以下步骤:
分配一个新的 SocketAsyncEventArgs 上下文对象,或者从应用程序池中获取一个空闲的此类对象。
将该上下文对象的属性设置为要执行的操作(例如,完成回调方法、数据缓冲区、缓冲区偏移量以及要传输的最大数据量)。
调用适当的套接字方法 (xxxAsync) 以启动异步操作。
如果异步套接字方法 (xxxAsync) 返回 true,则在回调中查询上下文属性来获取完成状态。
如果异步套接字方法 (xxxAsync) 返回 false,则说明操作是同步完成的。 可以查询上下文属性来获取操作结果。
将该上下文重用于另一个操作,将它放回到应用程序池中,或者将它丢弃。
分配一个新的 SocketAsyncEventArgs 上下文对象,或者从应用程序池中获取一个空闲的此类对象。
每一个SocketAsyncEventArgs对象中有以下几个重要属性:
public Socket AcceptSocket { get; set; }//accept后的socket对象赋给该对象,下次accept之前需要清除该对象(标为null)
public byte[] Buffer { get; }//每个对象对应的缓冲区
public int BytesTransferred { get; }//每次读取的字节数,类似于EndXXX完成后返回的字节数。
public int Offset { get; }//缓冲区的偏移量
public EndPoint RemoteEndPoint { get; set; }//目的源
public object UserToken { get; set; }//类似于BeginXXX中的小型类Object对象,很有用
public event EventHandler<SocketAsyncEventArgs> Completed;//响应IO的socket所有操作的事件
public void SetBuffer(int offset, int count);//缓冲区已设好,只需调整大小
public void SetBuffer(byte[] buffer, int offset, int count); //设置缓冲区,并设置大小这么多属性,自然需要很好的管理才行。第一个管理池就是SocketAsyncEventArgsPool,这就是上面步骤1中所说的应用程序池,该池用以管理每一个SocketAsyncEventArg对象,包括初始化,添加事件,出栈入栈(内部有栈)
将该上下文对象的属性设置为要执行的操作(例如,完成回调方法、数据缓冲区、缓冲区偏移量以及要传输的最大数据量)。
在上面的池中设置Comleted事件,并且调用SetBuffer去设置缓冲区,这时,就有第二个管理池出现,BufferManager
这个类创建了一大块内存区域,它将会被分成若干份,用以分配给每一个上下文对象的socket I/O操作,预分配内存可以很方便的进行内存重用,更重要的是这样可以防止内存碎片化。
注意:暴露在BfferManager类上的操作是非线程安全的
调用适当的套接字方法 (xxxAsync) 以启动异步操作。
若响应了IO操作,完成后则将进入Completed时间回调,这个时间回调就好比BeginXXX中的回调,但是比BeginXXX的回调要强大的多,该对象在这个回调中有一个LastOperation的枚举属性可以识别是哪种类型的操作,可以对此做出处理
如果异步套接字方法 (xxxAsync) 返回 true,则在回调中查询上下文属性来获取完成状态。
注意是Socket.XXXAsync,类似于BeginXXX
如果异步套接字方法 (xxxAsync) 返回 false,则说明操作是同步完成的。 可以查询上下文属性来获取操作结果。
这个我还真心没懂,因为还真没测出什么时候是同步的,有待研究
将该上下文重用于另一个操作,将它放回到应用程序池中,或者将它丢弃。
若不需要则进栈,服务器始终不删除该对象,初始化时便已经建立好了所有必备类和对象
经过上面的分析,应该很明朗了,看实现的代码:
1.BufferManager类
class BufferManager { int m_numBytes; //buffer大小 byte[] m_buffer; Stack<int> m_freeIndexPool; //管理池(栈操作) int m_currentIndex; int m_bufferSize; public BufferManager(int totalBytes, int bufferSize) { m_numBytes = totalBytes; m_currentIndex = 0; m_bufferSize = bufferSize; m_freeIndexPool = new Stack<int>(); } public void InitBuffer() { m_buffer = new byte[m_numBytes]; } //为上下文对象分配内存; //若栈中有数据则表明有内存曾今被回收过,则新的上下文对象就用这块内存 //否则就连续进行分配,直到内存满为止 public bool SetBuffer(SocketAsyncEventArgs args) { if (m_freeIndexPool.Count > 0) { args.SetBuffer(m_buffer, m_freeIndexPool.Pop(), m_bufferSize); } else { if ((m_numBytes - m_bufferSize) < m_currentIndex) { return false; } args.SetBuffer(m_buffer, m_currentIndex, m_bufferSize); m_currentIndex += m_bufferSize; } return true; } //从上下文中释放的内存都将放入管理池(栈)中 public void FreeBuffer(SocketAsyncEventArgs args) { m_freeIndexPool.Push(args.Offset); args.SetBuffer(null, 0, 0); } }
2.SocketAsyncEventArgsPool类
/// <summary> /// 该类定义可用的上下文对象集合 /// </summary> class SocketAsyncEventArgsPool { Stack<SocketAsyncEventArgs> m_pool; /// <summary> /// 初始化对象池 /// </summary> /// <param name="capacity">最大连接数量</param> public SocketAsyncEventArgsPool(int capacity) { m_pool = new Stack<SocketAsyncEventArgs>(capacity); } //回收对对象 public void Push(SocketAsyncEventArgs item) { if (item == null) { throw new ArgumentNullException("Items added to a SocketAsyncEventArgsPool cannot be null"); } lock (m_pool) { m_pool.Push(item); } } //分配对象 public SocketAsyncEventArgs Pop() { lock (m_pool) { return m_pool.Pop(); } } //对象个数 public int Count { get { return m_pool.Count; } } }
3.封装UserToken
//这个类是将UserToken进行了再次封装,MSDN对于异步Socket的介绍中总会提到: //若在异步回调中需要查询更多的信息,则应该建立一个小型类来管理回调时传递的Object对象 //UserToken其实就是那个传递的参数,AsyncUserToken就是对UserToken的封装,建立的小型类 public class AsyncUserToken { private Socket socket; public Socket Socket { get { return this.socket; } set { this.socket = value; } } //自定义的一些内容 private string id; public string ID { get { return this.id; } set { this.id = value; } } private string name; public string Name { get { return this.name; } set { this.name = value; } } }
4.具体组装以及实现
初始化:
//通过预分配可用的缓冲区和上下文来对象初始化服务器 //这些上下文对象大可不必在此预分配,它也暂时不会用到 //但是这么去创建可用的上下文对象会提高服务器的性能(避免局部多次new) public void Init() { //分配一大块内存,每一个I/O操作只用其中的一小段 //这将有效地防止内存碎片化 m_bufferManager.InitBuffer(); // 预分配异步操作池---读、写池 SocketAsyncEventArgs receiveArgs; SocketAsyncEventArgs sendArgs; for (int i = 0; i < m_numConnections; i++) { //接收 receiveArgs = new SocketAsyncEventArgs(); receiveArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnReceiveCompleted); receiveArgs.UserToken = new AsyncUserToken(); m_bufferManager.SetBuffer(receiveArgs); receiveArgsPool.Push(receiveArgs); //发送 sendArgs = new SocketAsyncEventArgs(); sendArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnSendCompleted); sendArgs.UserToken = new AsyncUserToken(); m_bufferManager.SetBuffer(sendArgs); sendArgsPool.Push(sendArgs); } }
监听:
//构造服务器时就开始启动监听 public void Start(IPEndPoint localEndPoint) { listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); listenSocket.Bind(localEndPoint); listenSocket.Listen(100); StartAccept(null); Console.WriteLine("请按任意键结束服务...."); Console.ReadKey(); } //开始接收连接请求 //当有数据时将会用上下文对象 public void StartAccept(SocketAsyncEventArgs acceptEventArg) { if (acceptEventArg == null) { acceptEventArg = new SocketAsyncEventArgs(); acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptEventArg_Completed); } else { //AcceptSocket必须每次都要清空,不然将会报错 acceptEventArg.AcceptSocket = null; } m_maxNumberAcceptedClients.WaitOne();//超过所连接客户端的数量后,将阻塞Accept操作 try { bool willRaiseEvent = listenSocket.AcceptAsync(acceptEventArg); if (!willRaiseEvent) { ProcessAccept(acceptEventArg); } } catch (Exception e) { } }
当监听中有数据时则进入以下事件:
//这个方法是与Socket.AcceptAsync操作有关的回调方法 //当一个accept操作完成后该方法将被调用 void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e) { ProcessAccept(e); }这个事件只和第一个startaccept中建立的对象绑定,也就说它只响应的是accept操作,这一点有点像Select模型中只有一个对象的情形。只是Select模型中当加入集合后一并处理,而这个模型是accept永远单独处理,剩下的操作自己做各种处理,觉得层次更清晰。
private void ProcessAccept(SocketAsyncEventArgs e) { try { Interlocked.Increment(ref m_numConnectedSockets); Console.WriteLine("Client connection accepted. There are {0} clients connected to the server", m_numConnectedSockets); //获取接收到的客户端,并将其放入对应的上下文对象的UserToken里 SocketAsyncEventArgs receiveArgs = receiveArgsPool.Pop(); AsyncUserToken token1 = receiveArgs.UserToken as AsyncUserToken; token1.Socket = e.AcceptSocket; SocketAsyncEventArgs sendArgs = sendArgsPool.Pop(); AsyncUserToken token2 = sendArgs.UserToken as AsyncUserToken; token2.Socket = e.AcceptSocket; lock (lockReceiveArgsList) { receiveArgsList.Add(receiveArgs); } lock (lockSendArgsList) { sendArgsList.Add(sendArgs); } //首先读一次,看有数据没 bool willRaiseEvent = e.AcceptSocket.ReceiveAsync(receiveArgs); if (!willRaiseEvent) { ProcessReceive(receiveArgs); } //递归,接受下一次的请求 StartAccept(e); } catch (Exception ex) { throw ex; } }receive事件:
//接收数据成功回调事件 void OnReceiveCompleted(object sender, SocketAsyncEventArgs e) { ProcessReceive(e); }
private void ProcessReceive(SocketAsyncEventArgs e) { try { // 查看客户端是否已经断掉 AsyncUserToken token = (AsyncUserToken)e.UserToken; if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success) { //原子性的计算总接收数据量 Interlocked.Add(ref m_totalBytesRead, e.BytesTransferred); Console.WriteLine("The server has read a total of {0} bytes", m_totalBytesRead); bool willRaiseEvent = token.Socket.ReceiveAsync(e); if (!willRaiseEvent) { ProcessReceive(e); } } } else { CloseClientSocket(e); } } catch (Exception ex) { throw ex; } }
总结:
该模型将socket的操作封装成了事件,并且解决了局部多次new缓冲区导致内存碎片化的尴尬。不过值得注意一点的是,在上面我生成了2个socket,一个发送一个接收,是因为此模型的双工需要建立两个对象。比如MSDN上的例子是服务器收到客户端的信息后直接返回给该客户端,这没问题,因为是C--->S,S---->C的形式。而如果现在有两个客户端C1,C2,若C1--->S,S---->C2则会报错“该套接字实例已经在进行异步操作了”,想想也是,当C1--->S时,S的LastOperation处于Receive状态,这是一个Comleted事件,此时该委托并没有执行完毕,若S--->C2则肯定会报错,为了不影响该线程,另建立一个专门发送的对象去执行发送,虽然它也绑定了Comleted事件,但是对象已经不同了,更不存在并发和线程冲突问题了。对于官方给出的模型还是有很多问题的,比如很多示例都有FreeBuffer的操作,在里面将Buffer清楚,但是当新客户端上来的时候,若分配了此对象,那它连缓冲区都没有,如何Receive呢,肯定会报错的,所以我觉得没有必要FreeBuffer,以前该对象在Buffer中的子区域是什么样,丢弃入栈的时候还是什么样,OffSet永远不变,变的只是Count.
- 几种Socket服务器模型比较!
- 几种Socket服务器模型比较!
- 几种Socket服务器模型比较!
- Java Socket编程(二) 几种常见的服务器模型
- 几种网络服务器模型的介绍与比较
- 几种网络服务器模型的介绍与比较
- 几种网络服务器模型的介绍与比较
- 几种服务器模型
- socket 的几种模型
- 使用事件驱动模型实现高效稳定的网络服务器程序 几种网络服务器模型的介绍与比较
- 服务器的几种模型
- 几种Web服务器比较
- 几种经典的网络服务器架构模型的分析与比较
- 几种经典的网络服务器架构模型的分析与比较 .
- 几种经典的网络服务器架构模型的分析与比较
- 几种经典的网络服务器架构模型的分析与比较
- 几种经典的网络服务器架构模型的分析与比较
- 几种经典的网络服务器架构模型的分析与比较
- 枚舉自定義屬性值讀取
- 【设计模式】工厂模式
- Linux 共享内存
- 灰度共生矩阵GLCM(Gray Level Co-occurrence Matrix)
- C++和JS的交互2 - Invoke .
- 几种Socket服务器模型比较!
- Window进程管理
- 利用编译器宏完美的输出调试信息
- 重构的一些原则
- Linux 信号量
- C语言练习之基础题
- unable to find valid certification path to requested target 的简单解决办法
- PPT报告的一些“技巧”
- poj 2524 - Ubiquitous Religions(并查集)