C# TCP客户端多线程问题：客户端断开无法触发Cleanup()

核心问题分析 #

你的handleClient方法里依赖networkstream.DataAvailable的死循环是关键问题——当客户端断开时，DataAvailable只会保持false，线程会一直卡在空循环里，无法进入异常处理或断开逻辑。监听线程th_StartListen之所以没捕获到异常，是因为客户端连接的处理逻辑是独立线程，异常不会向上冒泡到监听线程。

具体修复方案 #

1. 替换DataAvailable循环，改用带断开检测的读取逻辑

放弃空轮询DataAvailable，改用异步读取+取消令牌或带超时的同步读取，这样客户端断开时会触发异常或返回0字节，能及时进入Cleanup：

异步读取方案（推荐，不阻塞线程）

private async Task HandleClient(TcpClient client, CancellationTokenSource cts)
{
    NetworkStream networkStream = null;
    try
    {
        networkStream = client.GetStream();
        byte[] buffer = new byte[1024];
        
        while (!cts.Token.IsCancellationRequested)
        {
            int bytesRead = await networkStream.ReadAsync(buffer, 0, buffer.Length, cts.Token);
            
            // 客户端主动断开时，ReadAsync会返回0字节
            if (bytesRead == 0)
            {
                Cleanup(client, networkStream);
                break;
            }
            
            // 处理读取到的数据逻辑
            ProcessReceivedData(buffer, bytesRead);
        }
    }
    catch (IOException)
    {
        // 客户端意外断开、网络中断等IO异常
        Cleanup(client, networkStream);
    }
    catch (OperationCanceledException)
    {
        // 主动取消监听时触发
        Cleanup(client, networkStream);
    }
}

同步读取带超时方案

如果不想用异步，给NetworkStream设置读取超时，避免空循环卡住：

private void HandleClient(TcpClient client)
{
    NetworkStream networkStream = client.GetStream();
    networkStream.ReadTimeout = 500; // 设置500ms超时，避免无限阻塞
    byte[] buffer = new byte[1024];
    
    try
    {
        while (true)
        {
            int bytesRead;
            try
            {
                bytesRead = networkStream.Read(buffer, 0, buffer.Length);
            }
            catch (IOException ex)
            {
                // 区分超时和真实断开
                if (ex.InnerException is SocketException socketEx && 
                    socketEx.SocketErrorCode == SocketError.TimedOut)
                {
                    continue; // 超时，继续循环检测
                }
                // 其他IO异常，说明客户端断开
                Cleanup(client, networkStream);
                return;
            }
            
            if (bytesRead == 0)
            {
                // 客户端主动断开
                Cleanup(client, networkStream);
                return;
            }
            
            // 处理数据
            ProcessReceivedData(buffer, bytesRead);
        }
    }
    finally
    {
        // 确保资源释放，即使有未捕获异常
        Cleanup(client, networkStream);
    }
}

2. 修正监听线程的客户端处理逻辑

监听线程不要直接阻塞在HandleClient调用上，用Task启动独立任务处理客户端，同时确保每个客户端的处理逻辑都有自己的异常捕获：

private CancellationTokenSource _listenCts;
private bool _isListening;

public void StartListening()
{
    _listenCts = new CancellationTokenSource();
    _isListening = true;
    
    Task.Run(async () =>
    {
        TcpListener listener = new TcpListener(IPAddress.Any, 8888);
        listener.Start();
        
        try
        {
            while (_isListening && !_listenCts.Token.IsCancellationRequested)
            {
                // 异步接受连接，不阻塞监听线程
                TcpClient client = await listener.AcceptTcpClientAsync(_listenCts.Token);
                // 启动独立任务处理客户端，避免影响监听
                _ = HandleClient(client, _listenCts);
            }
        }
        catch (OperationCanceledException)
        {
            // 监听被主动取消，正常退出
        }
        finally
        {
            listener.Stop();
            _isListening = false;
        }
    }, _listenCts.Token);
}

3. 完善Cleanup方法的资源释放与状态更新

确保Cleanup能正确释放所有资源，并重新启动监听（如果需要）：

private void Cleanup(TcpClient client, NetworkStream stream)
{
    // 释放NetworkStream
    stream?.Close();
    stream?.Dispose();
    
    // 释放TcpClient
    client?.Close();
    client?.Dispose();
    
    // 更新连接状态
    _isConnected = false;
    
    // 如果监听已停止，重新启动监听
    if (!_isListening)
    {
        StartListening();
    }
}

关键注意点 #

• 永远不要依赖DataAvailable作为循环条件，它只是当前是否有数据可读的瞬时状态，无法检测客户端断开。
• 所有网络IO操作都要加异常捕获，客户端断开、网络中断都会抛出IOException。
• 使用CancellationToken统一管理线程取消，避免线程泄漏。

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