SOCKET 异步 连接过多时无法连接 C# Socket.Listen(int backlog)可以指定等待连接的队列长度,根据操作系统的不同,backlog 参数被限制为不同的值。您可以指定更大的值,但 backlog 将受操作系统的限制。默认是系统允许的最大值MaxConnections另外,用异步处理,多半是每个连接独立线程,线程那么多,也会影响效率就好像在搞DDOS攻击 解决方案 » 免费领取超大流量手机卡,每月29元包185G流量+100分钟通话, 中国电信官方发货 我指定的backlog是1w, 不小了吧? 我用的异步, 但是只用一个线程(底层怎么实现的我就不知道了)是不是accept的太慢了, 导致连接被挂起来了? 代码来喽! 我也是下别人的 /// <summary> /// 基于SocketAsyncEventArgs 实现 IOCP 服务器 /// </summary> internal sealed class IoServer { /// <summary> /// 监听Socket,用于接受客户端的连接请求 /// </summary> private Socket listenSocket; /// <summary> /// 用于服务器执行的互斥同步对象 /// </summary> private static Mutex mutex = new Mutex(); /// <summary> /// 用于每个I/O Socket操作的缓冲区大小 /// </summary> private Int32 bufferSize; /// <summary> /// 服务器上连接的客户端总数 /// </summary> private Int32 numConnectedSockets; /// <summary> /// 服务器能接受的最大连接数量 /// </summary> private Int32 numConnections; /// <summary> /// 完成端口上进行投递所用的IoContext对象池 /// </summary> private IoContextPool ioContextPool; public MainForm mainForm; /// <summary> /// 构造函数,建立一个未初始化的服务器实例 /// </summary> /// <param name="numConnections">服务器的最大连接数据</param> /// <param name="bufferSize"></param> internal IoServer(Int32 numConnections, Int32 bufferSize) { this.numConnectedSockets = 0; this.numConnections = numConnections; this.bufferSize = bufferSize; this.ioContextPool = new IoContextPool(numConnections); // 为IoContextPool预分配SocketAsyncEventArgs对象 for (Int32 i = 0; i < this.numConnections; i++) { SocketAsyncEventArgs ioContext = new SocketAsyncEventArgs(); ioContext.Completed += new EventHandler<SocketAsyncEventArgs>(OnIOCompleted); ioContext.SetBuffer(new Byte[this.bufferSize], 0, this.bufferSize); // 将预分配的对象加入SocketAsyncEventArgs对象池中 this.ioContextPool.Add(ioContext); } } /// <summary> /// 当Socket上的发送或接收请求被完成时,调用此函数 /// </summary> /// <param name="sender">激发事件的对象</param> /// <param name="e">与发送或接收完成操作相关联的SocketAsyncEventArg对象</param> private void OnIOCompleted(object sender, SocketAsyncEventArgs e) { // Determine which type of operation just completed and call the associated handler. switch (e.LastOperation) { case SocketAsyncOperation.Receive: this.ProcessReceive(e); break; case SocketAsyncOperation.Send: this.ProcessSend(e); break; default: throw new ArgumentException("The last operation completed on the socket was not a receive or send"); } } /// <summary> ///接收完成时处理函数 /// </summary> /// <param name="e">与接收完成操作相关联的SocketAsyncEventArg对象</param> private void ProcessReceive(SocketAsyncEventArgs e) { // 检查远程主机是否关闭连接 if (e.BytesTransferred > 0) { if (e.SocketError == SocketError.Success) { Socket s = (Socket)e.UserToken; //判断所有需接收的数据是否已经完成 if (s.Available == 0) { byte[] buffer = new byte[e.BytesTransferred]; Array.Copy(e.Buffer, buffer, e.BytesTransferred); string str = Encoding.ASCII.GetString(buffer); MainForm.lBps += str.Length; // 设置发送数据 Array.Copy(e.Buffer, 0, e.Buffer, e.BytesTransferred, e.BytesTransferred); e.SetBuffer(e.Offset, e.BytesTransferred * 2); if (!s.SendAsync(e)) //投递发送请求,这个函数有可能同步发送出去,这时返回false,并且不会引发SocketAsyncEventArgs.Completed事件 { // 同步发送时处理发送完成事件 this.ProcessSend(e); } } else if (!s.ReceiveAsync(e)) //为接收下一段数据,投递接收请求,这个函数有可能同步完成,这时返回false,并且不会引发SocketAsyncEventArgs.Completed事件 { // 同步接收时处理接收完成事件 this.ProcessReceive(e); } } else { this.ProcessError(e); } } else { this.CloseClientSocket(e); } } /// <summary> /// 发送完成时处理函数 /// </summary> /// <param name="e">与发送完成操作相关联的SocketAsyncEventArg对象</param> private void ProcessSend(SocketAsyncEventArgs e) { if (e.SocketError == SocketError.Success) { Socket s = (Socket)e.UserToken; //接收时根据接收的字节数收缩了缓冲区的大小,因此投递接收请求时,恢复缓冲区大小 e.SetBuffer(0, bufferSize); if (!s.ReceiveAsync(e)) //投递接收请求 { // 同步接收时处理接收完成事件 this.ProcessReceive(e); } } else { this.ProcessError(e); } } /// <summary> /// 处理socket错误 /// </summary> /// <param name="e"></param> private void ProcessError(SocketAsyncEventArgs e) { Socket s = e.UserToken as Socket; IPEndPoint localEp = s.LocalEndPoint as IPEndPoint; this.CloseClientSocket(s, e); string outStr = String.Format("套接字错误 {0}, IP {1}, 操作 {2}。", (Int32)e.SocketError, localEp, e.LastOperation); mainForm.Invoke(mainForm.setlistboxcallback, outStr); //Console.WriteLine("Socket error {0} on endpoint {1} during {2}.", (Int32)e.SocketError, localEp, e.LastOperation); } /// <summary> /// 关闭socket连接 /// </summary> /// <param name="e">SocketAsyncEventArg associated with the completed send/receive operation.</param> private void CloseClientSocket(SocketAsyncEventArgs e) { Socket s = e.UserToken as Socket; this.CloseClientSocket(s, e); } private void CloseClientSocket(Socket s, SocketAsyncEventArgs e) { Interlocked.Decrement(ref this.numConnectedSockets); // SocketAsyncEventArg 对象被释放,压入可重用队列。 this.ioContextPool.Push(e); string outStr = String.Format("客户 {0} 断开, 共有 {1} 个连接。", s.RemoteEndPoint.ToString(), this.numConnectedSockets); mainForm.Invoke(mainForm.setlistboxcallback, outStr); //Console.WriteLine("A client has been disconnected from the server. There are {0} clients connected to the server", this.numConnectedSockets); try { s.Shutdown(SocketShutdown.Send); } catch (Exception) { // Throw if client has closed, so it is not necessary to catch. } finally { s.Close(); } } /// <summary> /// accept 操作完成时回调函数 /// </summary> /// <param name="sender">Object who raised the event.</param> /// <param name="e">SocketAsyncEventArg associated with the completed accept operation.</param> private void OnAcceptCompleted(object sender, SocketAsyncEventArgs e) { this.ProcessAccept(e); } /// <summary> /// 监听Socket接受处理 /// </summary> /// <param name="e">SocketAsyncEventArg associated with the completed accept operation.</param> private void ProcessAccept(SocketAsyncEventArgs e) { Socket s = e.AcceptSocket; if (s.Connected) { try { SocketAsyncEventArgs ioContext = this.ioContextPool.Pop(); if (ioContext != null) { // 从接受的客户端连接中取数据配置ioContext ++MainForm.lAll; ioContext.UserToken = s; Interlocked.Increment(ref MainForm.lCount); Interlocked.Increment(ref this.numConnectedSockets); //string outStr = String.Format("客户 {0} 连入, 共有 {1} 个连接。", s.RemoteEndPoint.ToString(),this.numConnectedSockets); //mainForm.Invoke(mainForm.setlistboxcallback,outStr); //Console.WriteLine("Client connection accepted. There are {0} clients connected to the server", //this.numConnectedSockets); if (!s.ReceiveAsync(ioContext)) { this.ProcessReceive(ioContext); } } else //已经达到最大客户连接数量,在这接受连接,发送“连接已经达到最大数”,然后断开连接 { s.Send(Encoding.Default.GetBytes("连接已经达到最大数!")); string outStr = String.Format("连接已满,拒绝 {0} 的连接。", s.RemoteEndPoint); mainForm.Invoke(mainForm.setlistboxcallback, outStr); s.Close(); } } catch (SocketException ex) { Socket token = e.UserToken as Socket; string outStr = String.Format("接收客户 {0} 数据出错, 异常信息: {1} 。", token.RemoteEndPoint, ex.ToString()); mainForm.Invoke(mainForm.setlistboxcallback, outStr); //Console.WriteLine("Error when processing data received from {0}:\r\n{1}", token.RemoteEndPoint, ex.ToString()); } catch (Exception ex) { mainForm.Invoke(mainForm.setlistboxcallback, "异常:" + ex.ToString()); } // 投递下一个接受请求 this.StartAccept(e); } } /// <summary> /// 从客户端开始接受一个连接操作 /// </summary> /// <param name="acceptEventArg">The context object to use when issuing /// the accept operation on the server's listening socket.</param> private void StartAccept(SocketAsyncEventArgs acceptEventArg) { if (acceptEventArg == null) { acceptEventArg = new SocketAsyncEventArgs(); acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted); } else { // 重用前进行对象清理 acceptEventArg.AcceptSocket = null; } if (!this.listenSocket.AcceptAsync(acceptEventArg)) { this.ProcessAccept(acceptEventArg); } } /// <summary> /// 启动服务,开始监听 /// </summary> /// <param name="port">Port where the server will listen for connection requests.</param> internal void Start(Int32 port) { // 获得主机相关信息 IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList; IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Parse("192.168.0.253"), 55001);//addressList[addressList.Length - 1], port); // 创建监听socket this.listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); this.listenSocket.ReceiveBufferSize = this.bufferSize; this.listenSocket.SendBufferSize = this.bufferSize; this.listenSocket.Bind(localEndPoint); // 开始监听 this.listenSocket.Listen(this.numConnections); // 在监听Socket上投递一个接受请求。 this.StartAccept(null); // Blocks the current thread to receive incoming messages. mutex.WaitOne(); } /// <summary> /// 停止服务 /// </summary> internal void Stop() { this.listenSocket.Close(); mutex.ReleaseMutex(); } } /// <summary> /// 与每个客户Socket相关联,进行Send和Receive投递时所需要的参数 /// </summary> internal sealed class IoContextPool { List<SocketAsyncEventArgs> pool; //为每一个Socket客户端分配一个SocketAsyncEventArgs,用一个List管理,在程序启动时建立。 Int32 capacity; //pool对象池的容量 Int32 boundary; //已分配和未分配对象的边界,大的是已经分配的,小的是未分配的 internal IoContextPool(Int32 capacity) { this.pool = new List<SocketAsyncEventArgs>(capacity); this.boundary = 0; this.capacity = capacity; } /// <summary> /// 往pool对象池中增加新建立的对象,因为这个程序在启动时会建立好所有对象, /// 故这个方法只在初始化时会被调用,因此,没有加锁。 /// </summary> /// <param name="arg"></param> /// <returns></returns> internal bool Add(SocketAsyncEventArgs arg) { if (arg != null && pool.Count < capacity) { pool.Add(arg); boundary++; return true; } else return false; } /// <summary> /// 取出集合中指定对象,内部使用 /// </summary> /// <param name="index"></param> /// <returns></returns> //internal SocketAsyncEventArgs Get(int index) //{ // if (index >= 0 && index < capacity) // return pool[index]; // else // return null; //} /// <summary> /// 从对象池中取出一个对象,交给一个socket来进行投递请求操作 /// </summary> /// <returns></returns> internal SocketAsyncEventArgs Pop() { lock (this.pool) { if (boundary > 0) { --boundary; return pool[boundary]; } else return null; } } /// <summary> /// 一个socket客户断开,与其相关的IoContext被释放,重新投入Pool中,备用。 /// </summary> /// <param name="arg"></param> /// <returns></returns> internal bool Push(SocketAsyncEventArgs arg) { if (arg != null) { lock (this.pool) { int index = this.pool.IndexOf(arg, boundary); //找出被断开的客户,此处一定能查到,因此index不可能为-1,必定要大于0。 if (index == boundary) //正好是边界元素 boundary++; else { this.pool[index] = this.pool[boundary]; //将断开客户移到边界上,边界右移 this.pool[boundary++] = arg; } } return true; } else return false; } }private IoServer iocp = new IoServer(10000, 10240);iocp.Start(55001); private IoServer iocp = new IoServer(10000, 10240);你的缓冲区设太小了,调大一些试试看。private IoServer iocp = new IoServer(10000, 1024*1024); 前段时间研究了一下,卡在了双工通信的发送操作上,我想设置两个异步操作池,一个用于接收,一个用于发送,但发现不好实现数据发送的功能,感觉要先做一个发送缓冲队列,要发送的数据压入这个队列(主要是发送操作的buffer大小是固定的,但发送的数据可能会超过这个大小,需要手动分拆,这块我没法写出优雅的代码,感觉很乱),不知有没有高人指点一二? 我模拟的客户端有读数据库, 我邮箱:[email protected] 我用的就是MSDN上的示例代码,BTW,你那段代码其实也是MSDN的示例。有数据库读取的话,怀疑还是缓冲区不够,导致服务端来不及处理。 var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);socket.Bind(new IPEndPoint(IPAddress.Any, int.Parse(txt_port.Text)));socket.Listen(10000);socket.BeginAccept(new AsyncCallback(ClientAccepted), socket); public void ClientAccepted(IAsyncResult ar) { var socket = ar.AsyncState as Socket; }我这连接1W个 没什么问题.. 真心求救.急急..... 利用向导添加数据源出错,请指教一下吧 c#winform中怎么给 richTextBox 中的指定字加 下划线? 请推荐一些好的C#的Forms皮肤控件,最好免费,最好有下载地址,谢谢!! c#的控制台程序如何能使其 1打开就全屏,2改变其中的颜色 我现在学会了c#,可是还没有参与开发过,谁愿意要我? 关于组合框的事件,各位拜托了! 什么是数据库? 我想在一个按钮事件中打开一个新的ie窗口,怎么办? 怎样写注释才能让异常类型出现在注释Web页中? webBrowser1控件 连续请求返回同样的信息 求最大值,这语句有错吗?
我指定的backlog是1w, 不小了吧? 我用的异步, 但是只用一个线程(底层怎么实现的我就不知道了)是不是accept的太慢了, 导致连接被挂起来了?
/// <summary>
/// 基于SocketAsyncEventArgs 实现 IOCP 服务器
/// </summary>
internal sealed class IoServer
{
/// <summary>
/// 监听Socket,用于接受客户端的连接请求
/// </summary>
private Socket listenSocket; /// <summary>
/// 用于服务器执行的互斥同步对象
/// </summary>
private static Mutex mutex = new Mutex(); /// <summary>
/// 用于每个I/O Socket操作的缓冲区大小
/// </summary>
private Int32 bufferSize; /// <summary>
/// 服务器上连接的客户端总数
/// </summary>
private Int32 numConnectedSockets; /// <summary>
/// 服务器能接受的最大连接数量
/// </summary>
private Int32 numConnections; /// <summary>
/// 完成端口上进行投递所用的IoContext对象池
/// </summary>
private IoContextPool ioContextPool; public MainForm mainForm; /// <summary>
/// 构造函数,建立一个未初始化的服务器实例
/// </summary>
/// <param name="numConnections">服务器的最大连接数据</param>
/// <param name="bufferSize"></param>
internal IoServer(Int32 numConnections, Int32 bufferSize)
{
this.numConnectedSockets = 0;
this.numConnections = numConnections;
this.bufferSize = bufferSize; this.ioContextPool = new IoContextPool(numConnections); // 为IoContextPool预分配SocketAsyncEventArgs对象
for (Int32 i = 0; i < this.numConnections; i++)
{
SocketAsyncEventArgs ioContext = new SocketAsyncEventArgs();
ioContext.Completed += new EventHandler<SocketAsyncEventArgs>(OnIOCompleted);
ioContext.SetBuffer(new Byte[this.bufferSize], 0, this.bufferSize); // 将预分配的对象加入SocketAsyncEventArgs对象池中
this.ioContextPool.Add(ioContext);
}
} /// <summary>
/// 当Socket上的发送或接收请求被完成时,调用此函数
/// </summary>
/// <param name="sender">激发事件的对象</param>
/// <param name="e">与发送或接收完成操作相关联的SocketAsyncEventArg对象</param>
private void OnIOCompleted(object sender, SocketAsyncEventArgs e)
{
// Determine which type of operation just completed and call the associated handler.
switch (e.LastOperation)
{
case SocketAsyncOperation.Receive:
this.ProcessReceive(e);
break;
case SocketAsyncOperation.Send:
this.ProcessSend(e);
break;
default:
throw new ArgumentException("The last operation completed on the socket was not a receive or send");
}
} /// <summary>
///接收完成时处理函数
/// </summary>
/// <param name="e">与接收完成操作相关联的SocketAsyncEventArg对象</param>
private void ProcessReceive(SocketAsyncEventArgs e)
{
// 检查远程主机是否关闭连接
if (e.BytesTransferred > 0)
{
if (e.SocketError == SocketError.Success)
{
Socket s = (Socket)e.UserToken;
//判断所有需接收的数据是否已经完成
if (s.Available == 0)
{
byte[] buffer = new byte[e.BytesTransferred];
Array.Copy(e.Buffer, buffer, e.BytesTransferred);
string str = Encoding.ASCII.GetString(buffer); MainForm.lBps += str.Length; // 设置发送数据
Array.Copy(e.Buffer, 0, e.Buffer, e.BytesTransferred, e.BytesTransferred);
e.SetBuffer(e.Offset, e.BytesTransferred * 2);
if (!s.SendAsync(e)) //投递发送请求,这个函数有可能同步发送出去,这时返回false,并且不会引发SocketAsyncEventArgs.Completed事件
{
// 同步发送时处理发送完成事件
this.ProcessSend(e);
}
}
else if (!s.ReceiveAsync(e)) //为接收下一段数据,投递接收请求,这个函数有可能同步完成,这时返回false,并且不会引发SocketAsyncEventArgs.Completed事件
{
// 同步接收时处理接收完成事件
this.ProcessReceive(e);
}
}
else
{
this.ProcessError(e);
}
}
else
{
this.CloseClientSocket(e);
}
} /// <summary>
/// 发送完成时处理函数
/// </summary>
/// <param name="e">与发送完成操作相关联的SocketAsyncEventArg对象</param>
private void ProcessSend(SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
Socket s = (Socket)e.UserToken; //接收时根据接收的字节数收缩了缓冲区的大小,因此投递接收请求时,恢复缓冲区大小
e.SetBuffer(0, bufferSize);
if (!s.ReceiveAsync(e)) //投递接收请求
{
// 同步接收时处理接收完成事件
this.ProcessReceive(e);
}
}
else
{
this.ProcessError(e);
}
} /// <summary>
/// 处理socket错误
/// </summary>
/// <param name="e"></param>
private void ProcessError(SocketAsyncEventArgs e)
{
Socket s = e.UserToken as Socket;
IPEndPoint localEp = s.LocalEndPoint as IPEndPoint; this.CloseClientSocket(s, e); string outStr = String.Format("套接字错误 {0}, IP {1}, 操作 {2}。", (Int32)e.SocketError, localEp, e.LastOperation);
mainForm.Invoke(mainForm.setlistboxcallback, outStr);
//Console.WriteLine("Socket error {0} on endpoint {1} during {2}.", (Int32)e.SocketError, localEp, e.LastOperation);
} /// <summary>
/// 关闭socket连接
/// </summary>
/// <param name="e">SocketAsyncEventArg associated with the completed send/receive operation.</param>
private void CloseClientSocket(SocketAsyncEventArgs e)
{
Socket s = e.UserToken as Socket;
this.CloseClientSocket(s, e);
} private void CloseClientSocket(Socket s, SocketAsyncEventArgs e)
{
Interlocked.Decrement(ref this.numConnectedSockets); // SocketAsyncEventArg 对象被释放,压入可重用队列。
this.ioContextPool.Push(e);
string outStr = String.Format("客户 {0} 断开, 共有 {1} 个连接。", s.RemoteEndPoint.ToString(), this.numConnectedSockets);
mainForm.Invoke(mainForm.setlistboxcallback, outStr);
//Console.WriteLine("A client has been disconnected from the server. There are {0} clients connected to the server", this.numConnectedSockets);
try
{
s.Shutdown(SocketShutdown.Send);
}
catch (Exception)
{
// Throw if client has closed, so it is not necessary to catch.
}
finally
{
s.Close();
}
}
/// <summary>
/// accept 操作完成时回调函数
/// </summary>
/// <param name="sender">Object who raised the event.</param>
/// <param name="e">SocketAsyncEventArg associated with the completed accept operation.</param>
private void OnAcceptCompleted(object sender, SocketAsyncEventArgs e)
{
this.ProcessAccept(e);
} /// <summary>
/// 监听Socket接受处理
/// </summary>
/// <param name="e">SocketAsyncEventArg associated with the completed accept operation.</param>
private void ProcessAccept(SocketAsyncEventArgs e)
{
Socket s = e.AcceptSocket;
if (s.Connected)
{
try
{
SocketAsyncEventArgs ioContext = this.ioContextPool.Pop();
if (ioContext != null)
{
// 从接受的客户端连接中取数据配置ioContext
++MainForm.lAll; ioContext.UserToken = s;
Interlocked.Increment(ref MainForm.lCount);
Interlocked.Increment(ref this.numConnectedSockets);
//string outStr = String.Format("客户 {0} 连入, 共有 {1} 个连接。", s.RemoteEndPoint.ToString(),this.numConnectedSockets);
//mainForm.Invoke(mainForm.setlistboxcallback,outStr);
//Console.WriteLine("Client connection accepted. There are {0} clients connected to the server",
//this.numConnectedSockets); if (!s.ReceiveAsync(ioContext))
{
this.ProcessReceive(ioContext);
}
}
else //已经达到最大客户连接数量,在这接受连接,发送“连接已经达到最大数”,然后断开连接
{
s.Send(Encoding.Default.GetBytes("连接已经达到最大数!"));
string outStr = String.Format("连接已满,拒绝 {0} 的连接。", s.RemoteEndPoint);
mainForm.Invoke(mainForm.setlistboxcallback, outStr);
s.Close();
}
}
catch (SocketException ex)
{
Socket token = e.UserToken as Socket;
string outStr = String.Format("接收客户 {0} 数据出错, 异常信息: {1} 。", token.RemoteEndPoint, ex.ToString());
mainForm.Invoke(mainForm.setlistboxcallback, outStr);
//Console.WriteLine("Error when processing data received from {0}:\r\n{1}", token.RemoteEndPoint, ex.ToString());
}
catch (Exception ex)
{
mainForm.Invoke(mainForm.setlistboxcallback, "异常:" + ex.ToString());
}
// 投递下一个接受请求
this.StartAccept(e);
}
} /// <summary>
/// 从客户端开始接受一个连接操作
/// </summary>
/// <param name="acceptEventArg">The context object to use when issuing
/// the accept operation on the server's listening socket.</param>
private void StartAccept(SocketAsyncEventArgs acceptEventArg)
{
if (acceptEventArg == null)
{
acceptEventArg = new SocketAsyncEventArgs();
acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
}
else
{
// 重用前进行对象清理
acceptEventArg.AcceptSocket = null;
} if (!this.listenSocket.AcceptAsync(acceptEventArg))
{
this.ProcessAccept(acceptEventArg);
}
} /// <summary>
/// 启动服务,开始监听
/// </summary>
/// <param name="port">Port where the server will listen for connection requests.</param>
internal void Start(Int32 port)
{
// 获得主机相关信息
IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList;
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Parse("192.168.0.253"), 55001);//addressList[addressList.Length - 1], port); // 创建监听socket
this.listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
this.listenSocket.ReceiveBufferSize = this.bufferSize;
this.listenSocket.SendBufferSize = this.bufferSize; this.listenSocket.Bind(localEndPoint); // 开始监听
this.listenSocket.Listen(this.numConnections); // 在监听Socket上投递一个接受请求。
this.StartAccept(null); // Blocks the current thread to receive incoming messages.
mutex.WaitOne();
} /// <summary>
/// 停止服务
/// </summary>
internal void Stop()
{
this.listenSocket.Close();
mutex.ReleaseMutex();
} } /// <summary>
/// 与每个客户Socket相关联,进行Send和Receive投递时所需要的参数
/// </summary>
internal sealed class IoContextPool
{
List<SocketAsyncEventArgs> pool; //为每一个Socket客户端分配一个SocketAsyncEventArgs,用一个List管理,在程序启动时建立。
Int32 capacity; //pool对象池的容量
Int32 boundary; //已分配和未分配对象的边界,大的是已经分配的,小的是未分配的 internal IoContextPool(Int32 capacity)
{
this.pool = new List<SocketAsyncEventArgs>(capacity);
this.boundary = 0;
this.capacity = capacity;
} /// <summary>
/// 往pool对象池中增加新建立的对象,因为这个程序在启动时会建立好所有对象,
/// 故这个方法只在初始化时会被调用,因此,没有加锁。
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
internal bool Add(SocketAsyncEventArgs arg)
{
if (arg != null && pool.Count < capacity)
{
pool.Add(arg);
boundary++;
return true;
}
else
return false;
} /// <summary>
/// 取出集合中指定对象,内部使用
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
//internal SocketAsyncEventArgs Get(int index)
//{
// if (index >= 0 && index < capacity)
// return pool[index];
// else
// return null;
//} /// <summary>
/// 从对象池中取出一个对象,交给一个socket来进行投递请求操作
/// </summary>
/// <returns></returns>
internal SocketAsyncEventArgs Pop()
{
lock (this.pool)
{
if (boundary > 0)
{
--boundary;
return pool[boundary];
}
else
return null;
}
} /// <summary>
/// 一个socket客户断开,与其相关的IoContext被释放,重新投入Pool中,备用。
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
internal bool Push(SocketAsyncEventArgs arg)
{
if (arg != null)
{
lock (this.pool)
{
int index = this.pool.IndexOf(arg, boundary); //找出被断开的客户,此处一定能查到,因此index不可能为-1,必定要大于0。
if (index == boundary) //正好是边界元素
boundary++;
else
{
this.pool[index] = this.pool[boundary]; //将断开客户移到边界上,边界右移
this.pool[boundary++] = arg;
}
}
return true;
}
else
return false;
}
}private IoServer iocp = new IoServer(10000, 10240);
iocp.Start(55001);
你的缓冲区设太小了,调大一些试试看。
private IoServer iocp = new IoServer(10000, 1024*1024);
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Bind(new IPEndPoint(IPAddress.Any, int.Parse(txt_port.Text)));
socket.Listen(10000);
socket.BeginAccept(new AsyncCallback(ClientAccepted), socket);
public void ClientAccepted(IAsyncResult ar)
{
var socket = ar.AsyncState as Socket;
}
我这连接1W个 没什么问题..