前言

前面一篇文章全部用的是阻塞API，也就是同步Socket程序，客户端一卡一顿、服务端只能一次处理一个客户端的消息，不具有实用性。
所有有了异步和多路复用两种技术解决了阻塞问题。

2.1什么是异步代码

不需要进程一直等待下去，而是继续往下执行，直到满足条件才调用回调函数，这样可以提高执行的效率。
异步的实现依赖于多线程技术。在Unity中，执行Start、Update方法的线程是主线程，会另外开一条线程执行异步代码，然后满足条件后另一条线程调用回调函数，主线程继续往下执行代码，不受影响。

2.2异步客户端

2.2.1异步Connect

每一个同步API对应两个异步API，分别是在原名称前加上Begin和End。
如果使用Connect且服务端没有答复，那么用户在尝试连接这段时间内不能做任何操作，体验极差。
这里就介绍一个BeginConnect的函数原型，后面出现的异步API都大同小异

public IAsyncResult BeginConnect(string host,//远程主机IPint port,//远程主机端口号AsyncCallback requestCallback,//回调函数形式：void ConnectCallback(IAsyncResult ar)object state//一般用自定义的客户端类来传进去，一般包含链接操作的相关信息，会被传递给callback
)

IAsyncResult是.NET提供的一步操作，通过begin…和end…完成原同步方法的异步调用。begin…包含回调委托和用户定义的状态对象，返回一个实现IAsyncResult接口的对象。end…用于结束一步操作返回结果，返回值和同步方法相同。

2.2.2异步客户端代码

里面的代码有点乱，因为我是把一整章的代码打完才写文章的。

//点击连接按钮public void Connection(){//新建sockect//地址族IPV4,套接字类型stream,协议类型socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//connect//远程IP地址,远程端口，阻塞方法，卡住直到服务端回应、//自己建立服务器的话，ip地址和端口号就是这两个//socket.Connect("127.0.0.1", 8888);//异步socket.BeginConnect("127.0.0.1", 8888, ConnectCallback, socket);}//Connect回调public void ConnectCallback(IAsyncResult ar){try{//此socket可由ar.AsyncState获取到Socket socket = (Socket)ar.AsyncState;socket.EndConnect(ar);Debug.Log("Socket Connect Succ");//接收缓冲区、0表示从readBuff第0位开始接收数据(和TCP粘包问题有关)、每次最多接收1024字节数据(即使服务器发送1025,也只接收1024)//接收函数调用时机：在连接成功后就开始接受数据，接收到数据后，回调函数ReceiveCallback被调用socket.BeginReceive(readBuff, 0, 1024, 0, ReceiveCallback, socket);}catch (SocketException ex){Debug.Log("Socket Connect fail" + ex.ToString());}}//Receive回调public void ReceiveCallback(IAsyncResult ar){try{Socket socket = (Socket)ar.AsyncState;int count = socket.EndReceive(ar);string s = System.Text.Encoding.Default.GetString(readBuff, 0, count);recvStr = s + "\n" + recvStr;//接收完一串数据后，等待下一串数据的到来socket.BeginReceive(readBuff, 0, 1024, 0, ReceiveCallback, socket);}catch (SocketException ex){Debug.Log("Socket Receive fail" + ex.ToString());}}//点击发送按钮public void Send(){//sendif (canSend){string sendStr = InputField.text;//string sendStr = System.DateTime.Now.ToString();//将str转化为字节流byte[] sendBytes = System.Text.Encoding.Default.GetBytes(sendStr);//socket.BeginSend(sendBytes, 0, sendBytes.Length, 0, SendCallback, socket);socket.Send(sendBytes);}//异步不需要receive//Recv//byte[] readBuff = new byte[1024];接收数据的长度//int count = socket.Receive(readBuff);//string recvStr = System.Text.Encoding.Default.GetString(readBuff, 0, count);//text.text = recvStr;Close//socket.Close();}//Send回调public void SendCallback(IAsyncResult ar){try{//这个socket是传进回调的用户定义对象，可强转为socketSocket socket = (Socket)ar.AsyncState;int count = socket.EndSend(ar);Debug.Log("Socket Send succ" + count);}catch(SocketException ex){Debug.Log("Socket Send fail" + ex.ToString());}}

大致讲几个重点部分：

• Connect会等待服务端应答导致卡顿、Receive会等到收到服务端数据卡顿、send会等到接收方确认收到消息而卡顿，我们把这些都换成了异步方法。
• BeginReceive的调用位置分别在ConnectCallback，在连接成功后就开始接收数据，收到数据后，回调函数ReceiveCallback被调用。另一个就是在BeginReceive内部，接收完一串数据后，等待下一串数据的到来。
• 在Unity中只有主线程可以操控UI组件，所以在其他线程执行的异步回调不能直接给text赋值，只能给一个全局变量赋值然后再给text赋值
• Send有发送缓冲区，如果满了（也就是服务端不接收且一直发送的情况），就会卡住。而且send只是把数据写入到缓冲区，返回只代表成功将数据发送到缓存区，对方可能没有收到数据。

2.3异步服务端

同步服务端同一时间只能处理一个客户端的请求，用异步方法就可以同时处理多个。

2.3.1管理客户端

因为服务端需要转发某个客户端发送来的消息给所有客户端，所以要有列表平保存所有连接到该服务端的客户端。
这个socket是服务端用于回应这个客户端的socket对象，并不是客户端用于连接的socket。
readBuff是填充BeginReceive参数的读缓冲区

class ClientState{public Socket socket;public byte[] readBuff = new byte[1024];}

再用方便获取客户端信息

static Dictionary<Socket, ClientState> clients = new Dictionary<Socket, ClientState>();

2.3.2服务端代码

using System;
using System.Net;
using System.Net.Sockets;
using System.Collections.Generic;namespace ConsoleApp1
{class ClientState{public Socket socket;public byte[] readBuff = new byte[1024];}class MainClass{//异步服务器//监听Socketstatic Socket listenfd;//客户端Socket及状态信息static Dictionary<Socket, ClientState> clients = new Dictionary<Socket, ClientState>();public static void Main(string[] args){Console.WriteLine("Hello");//SocketSocket listenfd = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//BindIPAddress ipAdr = IPAddress.Parse("127.0.0.1");//IP地址IPEndPoint ipEp = new IPEndPoint(ipAdr, 8888);//IP和端口//给listenfd套接字绑定IP和端口,"127.0.0.1"地址和8888号端口listenfd.Bind(ipEp);//Listen，等待客户端连接//0表示容纳等待接收的客户端连接数不受限制，1代表最多可容纳等待接受的连接数为1listenfd.Listen(0);Console.WriteLine("[服务器]启动成功");//异步服务器listenfd.BeginAccept(AcceptCallback, listenfd);//等待Console.ReadLine();}
//Accept回调//是beginaccept的回调函数，处理3件事//1.给新的连接分配ClientState，并把它加入到clients列表中//2.异步接收客户端数据//3.再次调用BeginAccept循环public static void AcceptCallback(IAsyncResult ar){try{Console.WriteLine("[服务器]Accept");//监听和应答客户端的socketSocket listenfd = (Socket)ar.AsyncState;//处理该客户端的socketSocket clientfd = listenfd.EndAccept(ar);//clients列表ClientState state = new ClientState();//初始化此客户端类，key和value岂不是重复利用了？state.socket = clientfd;clients.Add(clientfd, state);//接收数据BeginReceive，以ClientState取代Socketclientfd.BeginReceive(state.readBuff, 0, 1024, 0, ReceiveCallback, state);//继续Acceptlistenfd.BeginAccept(AcceptCallback, listenfd);}catch(SocketException ex){Console.WriteLine("Socket Accept fail" + ex.ToString());}}//Receive回调//1.服务端收到消息后，回应客户端//2.如果收到客户端关闭连接的信号"if(count==0)"，断开连接//3.继续调用BeginReceive接收下一个数据public static void ReceiveCallback(IAsyncResult ar){try{//发送消息的客户端ClientState state = (ClientState)ar.AsyncState;Socket clientfd = state.socket;//当receive返回值小于等于0时，表示socket连接可以断开int count = clientfd.EndReceive(ar);//客户端关闭if(count == 0){clientfd.Close();clients.Remove(clientfd);Console.WriteLine("Socket Close");return;}//从收到的字节流转为stringstring recvStr = System.Text.Encoding.Default.GetString(state.readBuff, 0, count);string sendStr = clientfd.RemoteEndPoint.ToString() + ":" + recvStr;byte[] sendBytes = System.Text.Encoding.Default.GetBytes(sendStr);//string转为bytes//用于处理该客户端数据的socketforeach(ClientState s in clients.Values){s.socket.Send(sendBytes);}clientfd.BeginReceive(state.readBuff, 0, 1024, 0, ReceiveCallback, state);}catch(SocketException ex){Console.WriteLine("Socket Receive fail" + ex.ToString());}}}

重点：

• 将Accept和Receive变为异步。否则Accept会一直阻塞在该语句上，用了异步后，等客户端连接上来回调函数就会被执行。可用EndAccept获取新客户端的socket。
• 异步服务器结构：Socket、Bind、Listen初始化后监听socket，用BeginAccept异步处理客户端连接，如有连接就调用AcceptCallback回调，让客户端开始接受数据。再急需调用BeginAccept等待下一个连接
• 当Receive返回值小于等于0时，表示连接断开，可以关闭Socket。

2.5状态监测Poll

在阻塞方法前面加上一层判断，有数据可读时调用Receive，有数据写调用Send，这就是Poll。
Socket类的Poll方法：

public bool Poll(int microSeconds,SelectMode mode
)

第一个参数是等待回应的时间，以ms为单位，如果为-1就一直等待，如果为0表示非阻塞(不希望阻塞就写0）。
mode有三种可选模式，不细嗦了

2.5.1Poll客户端

卡住客户端最大的问题就是阻塞Receive，只要在Update里不停判断有没有数据可读，有数据可读才调用Receive就行了
一般客户端的poll设为不阻塞模式

public void Update(){if(socket == null){return;}//poll客户端if (socket.Poll(0, SelectMode.SelectRead)){byte[] readBuff = new byte[1024];int count = socket.Receive(readBuff);//不阻塞模式，microSeconds=0string recvStr = System.Text.Encoding.Default.GetString(readBuff, 0, count);text.text = recvStr;}//处理阻塞send应该也差不多if (socket.Poll(0, SelectMode.SelectWrite)){canSend = true;}else{canSend = false;}}

比异步的套娃简洁，该干嘛时干嘛即可。

2.5.3Poll服务端

注意点：

• 不断检测 监听Socket(llistenfd)和各个客户端Socket的状态，如果监听Socket可读意味有客户端连接，就Aceept回应，并将其加入列表。客户端socket可读，就转发它的消息给所有客户端
• while循环最后有一个sleep让程序挂起1ms，避免死循环。
• 如果收到长度为0的数据就直接break循环，因为为0就会将这个客户端踢出列表，再遍历它会出错。
• Poll超时时间设为0，可以及时处理多个客户端连接，但是导致CPU占用率高
• 最后两个Read函数和对应的回调做的事差不多，都是条件达到了就调用

		public static void Main(string[] args){Console.WriteLine("Hello");//SocketSocket listenfd = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//BindIPAddress ipAdr = IPAddress.Parse("127.0.0.1");//IP地址IPEndPoint ipEp = new IPEndPoint(ipAdr, 8888);//IP和端口//给listenfd套接字绑定IP和端口,"127.0.0.1"地址和8888号端口listenfd.Bind(ipEp);//Listen，等待客户端连接//0表示容纳等待接收的客户端连接数不受限制，1代表最多可容纳等待接受的连接数为1listenfd.Listen(0);Console.WriteLine("[服务器]启动成功");while (true){//检查listenfd，可读就添加客户端信息if (listenfd.Poll(0, SelectMode.SelectRead)){ReadListenfd(listenfd);}//检查clientfdforeach (ClientState s in clients.Values){Socket clientfd = s.socket;if (clientfd.Poll(0, SelectMode.SelectRead)){//false表示客户端断开(收到长度为0的数据)//断开会删掉列表中对应的信息，导致遍历失败，所以直接breakif (!ReadClientfd(clientfd)){break;}}}//防止CPU占用过高//让程序挂起1ms，避免死循环让CPU喘息System.Threading.Thread.Sleep(1);}}public static void ReadListenfd(Socket listenfd){Console.WriteLine("Accept");Socket clientfd = listenfd.Accept();ClientState state = new ClientState();state.socket = clientfd;clients.Add(clientfd, state);}//和异步服务端的Receivecallback类似，用于接收客户端消息，并广播给所有客户端public static bool ReadClientfd(Socket clientfd){ClientState state = clients[clientfd];//接收int count = 0;try{count = clientfd.Receive(state.readBuff);}catch(SocketException ex){clientfd.Close();clients.Remove(clientfd);Console.WriteLine("Receive SocketException" + ex.ToString());return false;}//让客户端关闭if(count == 0){clientfd.Close();clients.Remove(clientfd);Console.WriteLine("Socket Close");return false;}//广播string recvStr = System.Text.Encoding.Default.GetString(state.readBuff, 0, count);Console.WriteLine("Receive" + recvStr);//发送回去的是ip+收到的string sendStr = clientfd.RemoteEndPoint.ToString() + ":" + recvStr;byte[] sendBytes = System.Text.Encoding.Default.GetBytes(sendStr);foreach (ClientState cs in clients.Values){cs.socket.Send(sendBytes);}return true;}

2.6多路复用Select

2.6.1什么是多路复用

虽然Poll逻辑清晰，但是弊端也很明显，比如服务端没有收到客户端数据也一直循环，浪费Cpu。
所以有了多路复用，也就是同时处理多路信号，比如同时检测多个Socket的状态。
办法就是：在需要坚挺的Socket列表中，如果有一个(or多个)Socket可读(or可写or错误)，就返回这些Scoket加入对应的列表。

Public static void Select(IList checkRead,IList checkWrite,IList checkError,int microSeconds
)

将需要检测的socket加入对应列表后，作为这函数的参数被调用就会改变原列表，只会留下符合要求的。当没有符合要求的socket就会阻塞。

2.6.2Select服务端

仍然使用while(true){…}结构，不断调用Select检测Socket状态。如果不为空就调用对应的函数，类似回调，处理对应的socket。

			//select服务器//checkReadList<Socket> checkRead = new List<Socket>();//主循环while (true){//填充checkRead列表checkRead.Clear();checkRead.Add(listenfd);foreach (ClientState s in clients.Values){checkRead.Add(s.socket);}//select，只将待检查可读的列表传进去Socket.Select(checkRead, null, null, 1000);//调用完上面的方法后这个列表就被改了，这个列表中只有可读的socketforeach (Socket s in checkRead){//因为listnfd本身就被加进去了if (s == listenfd){ReadListenfd(s);}//除了listen其余都是可读的客户端，直接处理即可else{ReadClientfd(s);}}}

2.6.3Select客户端

代码在update中，和poll客户端极其相似，而且只需要检查一个socket。
**问题在于，如果没有可读的，是会卡住update线程吗？？**可能它本身就是开启一个异步线程来检测，卡住的是异步线程

		checkRead.Clear();checkRead.Add(socket);//selectSocket.Select(checkRead, null, null, 0);//checkforeach (Socket s in checkRead){byte[] readBuff = new byte[1024];int count = socket.Receive(readBuff);string recvStr = System.Text.Encoding.Default.GetString(readBuff, 0, count);text.text = recvStr;}

在Update监测数据性能太差，商业上一般使用异步或者用多线程模拟异步