看起来你在搭建Dealer/Router多客户端架构时遇到了连接数瓶颈，我帮你分析下代码里的问题以及对应的优化方案，应该能帮你突破当前的连接限制：

1. 修复客户端Poller的生命周期问题 #

你的客户端代码里，StartSending方法中的NetMQPoller被包裹在using块中，这意味着方法执行完毕后，poller会立即被释放，连带你的DealerSocket也会被停止并清理，这直接导致很多客户端连接无法维持。

修改方案：把poller作为客户端类的成员变量，让它和客户端实例同生命周期：

public class NetMQClient : IDisposable {
    private DealerSocket _client;
    private NetMQQueue<NetMQMessage> _messageQueue;
    private NetMQPoller _poller; // 作为成员变量

    public NetMQClient () {
        _client = new DealerSocket("tcp://127.0.0.1:25702");
        _messageQueue = new NetMQQueue<NetMQMessage>();
        
        _messageQueue.ReceiveReady += MessageQueue_ReceiveReady;
        _client.Options.Backlog = 1000;
        _client.ReceiveReady += Client_ReceiveReady;

        // 初始化poller并保持运行
        _poller = new NetMQPoller();
        _poller.Add(_client);
        _poller.Add(_messageQueue);
        _poller.RunAsync();
    }

    public void StartSending(int id) {
        _client.Options.Identity = Encoding.Unicode.GetBytes(id.ToString());
        var message = string.Format("Id = {0}", id.ToString());
        
        var messageToServer = new NetMQMessage();
        messageToServer.Append(message);
        _messageQueue.Enqueue(messageToServer);
    }

    private void Client_ReceiveReady(object sender, NetMQSocketEventArgs e) {
        while (e.Socket.TryReceiveFrameString(out string msg)) {
            Console.WriteLine("REPLY From Server{0}", msg);
        }
    }

    private void MessageQueue_ReceiveReady(object sender, NetMQQueueEventArgs<NetMQMessage> e) {
        while (e.Queue.TryDequeue(out NetMQMessage messageToServer, TimeSpan.FromMilliseconds(10))) {
            _client.SendMultipartMessage(messageToServer);
        }
    }

    // 实现IDisposable释放资源
    public void Dispose() {
        _poller?.Stop();
        _poller?.Dispose();
        _client?.Dispose();
        _messageQueue?.Dispose();
    }
}

2. 控制客户端的并发创建速度 #

你当前的代码是瞬间启动1000个Task来创建客户端，这会导致系统瞬间创建大量TCP连接，超出NetMQ或操作系统的处理能力，进而导致连接失败。

修改客户端启动逻辑，用SemaphoreSlim控制并发创建的数量：

class Program {
    static void Main(string[] args) {
        var semaphore = new SemaphoreSlim(50); // 每次最多创建50个客户端
        Task.Factory.StartNew(async () => {
            for (var i = 1; i <= 1000; i++) {
                await semaphore.WaitAsync();
                var index = i;
                Task.Run(() => {
                    try {
                        var client = new NetMQClient();
                        client.StartSending(index);
                    }
                    finally {
                        semaphore.Release();
                    }
                });
                // 每批创建后短暂延迟，给系统缓冲时间
                if (i % 50 == 0) await Task.Delay(100);
            }
        });
        Console.WriteLine("Press any key to finish!");
        Console.ReadLine();
    }
}

3. 优化NetMQ Socket的关键配置 #

除了Backlog，还需要调整几个关键参数来支持大量连接，客户端和服务端都要设置：

// 设置高水位线，避免消息积压导致连接被断开
socket.Options.SendHighWatermark = 1000;
socket.Options.ReceiveHighWatermark = 1000;

// 启用TCP保活，维持空闲连接不被回收
socket.Options.TcpKeepalive = true;
socket.Options.TcpKeepaliveIdle = TimeSpan.FromMinutes(5);
socket.Options.TcpKeepaliveInterval = TimeSpan.FromSeconds(30);

服务端额外优化：避免阻塞Poller #

不要在ReceiveReady事件中直接处理消息，把消息逻辑放到后台线程，防止阻塞Poller影响新连接接收：

private void Server_ReceiveReady(object sender, NetMQSocketEventArgs e) {
    var fromClientMessage = new NetMQMessage();
    while (server.TryReceiveMultipartMessage(ref fromClientMessage)) {
        // 复制消息到后台线程处理
        var messageCopy = new NetMQMessage(fromClientMessage);
        Task.Run(() => ProcessClientMessage(messageCopy));
    }
}

private void ProcessClientMessage(NetMQMessage message) {
    var clientAddress = message[0];
    var clientOriginalMessage = message[1].ConvertToString();
    Console.WriteLine("From Client: {0}", clientOriginalMessage);
    
    var messageToClient = new NetMQMessage();
    messageToClient.Append(clientAddress);
    messageToClient.Append(clientOriginalMessage);
    
    lock (server) { // NetMQ Socket非线程安全，加锁保证发送安全
        server.SendMultipartMessage(messageToClient);
    }
}

4. 调整系统级别的连接限制 #

如果上述代码优化后还是无法达到千级连接，需要调整操作系统的套接字限制：

Linux系统： #

1. 临时调整（重启后失效）：

   ulimit -n 65535 # 提升打开文件描述符上限
   

2. 永久调整：编辑/etc/security/limits.conf，添加：

   * soft nofile 65535
   * hard nofile 65535
   

Windows系统： #

修改注册表调整TCP参数：

1. 打开注册表编辑器，定位到HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters
2. 添加或修改以下DWORD值：
   • MaxUserPort：设置为65534（最大可用端口数）
   • TcpTimedWaitDelay：设置为30（减少TIME_WAIT状态的端口占用时间）

总结 #

通过修复Poller生命周期、控制并发创建速度、优化NetMQ配置和调整系统限制，应该能轻松实现千级客户端连接。这些调整不仅解决当前的连接瓶颈，还能提升整个架构的稳定性和性能。

内容的提问来源于stack exchange，提问作者mariovalens