Java TCP多客户端与服务器Ping/Pong通信故障排查求助

我需要实现4个客户端与服务器基于TCP协议的通信连接，目前已成功建立客户端与服务器的连接，但当服务器发送PING消息时，客户端无法正确识别该消息，因此无法返回PONG消息，最终导致连接在15秒后断开。现附上客户端核心代码，恳请帮忙分析问题所在及改进建议。

核心代码 #

Client类 #

import java.net.*;
import java.io.*;

public class Client {
    public static void main(String[] args) {
        try {
            Socket sock = new Socket(args[0], Integer.parseInt(args[1]));
            InputStream in = sock.getInputStream();
            OutputStream out= sock.getOutputStream();

            // 创建读取服务器消息的线程
            InThread th = new InThread(in);
            Thread iT = new Thread(th);
            iT.start();

            PongThread pongThread = new PongThread(sock);
            Thread pongT = new Thread(pongThread);
            pongT.start();

            // 控制台输入处理
            BufferedReader conin = new BufferedReader(new InputStreamReader(System.in));
            String line = " ";
            while (true) {
                // 读取控制台输入
                line = conin.readLine();
                if (line.equalsIgnoreCase("QUIT")) {
                    //sendQuitMessage(); 或直接调用协议处理类的方法
                    break;
                } else if (line.startsWith("/nick")){
                    //changeNickname(line.substring(6)); 或调用协议处理类的方法
                } else {
                    //sendMessage(line); 或调用协议处理类的方法
                }
            }
            // 终止程序
            System.out.println("Terminating ...");
            in.close();
            out.close();
            sock.close();
        } catch (IOException e) {
            System.err.println("Error: " + e.toString());
        }
    }
}

PongThread类 #

import java.io.*;
import java.net.Socket;

/**
 * 监听服务器PING消息并返回PONG消息的类，需在独立线程运行以维持连接
 */
class PongThread implements Runnable {
    private final Socket clientSocket;
    private boolean running;

    /**
     * 构造方法，传入客户端Socket
     *
     * @param clientSocket 用于读取消息的Socket
     *
     */
    public PongThread(Socket clientSocket) {
        this.clientSocket = clientSocket;
        this.running = true;
    }

    /**
     * 监听PING消息并发送PONG响应，持续读取输入流中的消息
     */
    public void run() {
        try {
            InputStream in = clientSocket.getInputStream();
            OutputStream out = clientSocket.getOutputStream();

            while (running) {
                // 等待PING消息
                long startTime = System.currentTimeMillis();

                while (System.currentTimeMillis() - startTime < 15000) {
                    if (in.available() > 0) {
                        String response = readCommand(in);
                        if (Command.PING.name().equals(response)) {
                            System.out.println(response);
                            sendCommand(out, Command.PONG.name()); //发送PONG消息
                            System.out.println("PONG sent");
                            startTime = System.currentTimeMillis(); //重置计时
                            break; //收到PING，退出循环
                        }
                    }
                }
                if (System.currentTimeMillis() - startTime >= 15000) {
                    System.out.println("Server lost connection.");
                    running = false;
                    clientSocket.close();
                }
            }
        } catch (IOException e) {
            System.err.println("ERROR with server connection: " + e.toString());
        }
    }
    private void sendCommand(OutputStream out, String command) throws IOException {
        out.write((command + Command.SEPARATOR).getBytes());
    }

    private String readCommand(InputStream in) throws IOException {
        byte[] buffer = new byte[256];
        int bytesRead = in.read(buffer);
        return new String(buffer, 0, bytesRead).trim();
    }

    public void stopPinging() {
        running = false;
    }
}

InThread类 #

import java.io.*;

/**
 * 从输入流读取数据并输出到控制台的可运行类，需在独立线程运行以持续读取网络Socket数据
 *
 * @author julia
 * @since 21.03.2025
 */
class InThread implements Runnable {
    private InputStream in;

    /**
     * 构造方法，传入输入流
     *
     * @param in 要读取的输入流
     */
    public InThread(InputStream in) {
        this.in = in;
    }

    /**
     * 从输入流读取数据并输出到控制台，持续读取直到流结束（read()返回-1）
     */
    public void run() {
        byte[] buffer = new byte[1024]; // 增大缓冲区大小
        int bytesRead;
        try {
            while ((bytesRead = in.read(buffer)) != -1) {
                System.out.write(buffer, 0, bytesRead);
                System.out.flush(); // 确保输出被刷新
            }
        } catch (IOException e) {
            System.err.println("ERROR: " + e.toString());
        }
    }
}

问题分析 #

1. 输入流被多线程抢占：InThread和PongThread同时读取同一个Socket输入流，InThread会持续读取所有流数据，导致PongThread无法获取到PING消息。
2. 消息边界处理缺失：TCP是字节流协议，readCommand直接读取缓冲区数据的逻辑无法处理粘包/拆包问题，若PING消息被拆分或与其他消息合并，解析出的字符串无法匹配Command.PING.name()。
3. 计时逻辑漏洞：仅在匹配到PING时重置计时，收到其他消息不会重置；空循环检测in.available()会浪费CPU资源，且可能因线程调度延迟导致超时误判。

改进建议 #

1. 统一消息处理线程 #

取消双线程读取设计，用单个线程负责所有服务器消息的读取与分发：

• 读取完整消息后，判断类型：PING则回复PONG，其他消息输出到控制台。

2. 实现可靠的消息边界解析 #

基于协议中的Command.SEPARATOR分隔符，修改读取逻辑确保拿到完整消息：

private String readFullCommand(InputStream in) throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    int b;
    while ((b = in.read()) != -1) {
        if (b == Command.SEPARATOR.charAt(0)) {
            break;
        }
        baos.write(b);
    }
    return baos.toString().trim();
}

3. 优化连接保活逻辑 #

收到任何消息都重置超时计时，用Thread.sleep()替代空循环减少CPU消耗：

while (running) {
    long startTime = System.currentTimeMillis();
    boolean hasMessage = false;
    while (System.currentTimeMillis() - startTime < 15000) {
        if (in.available() > 0) {
            String command = readFullCommand(in);
            hasMessage = true;
            if (Command.PING.name().equals(command)) {
                sendCommand(out, Command.PONG.name());
                System.out.println("Received PING, sent PONG");
            } else {
                System.out.println("Server message: " + command);
            }
            startTime = System.currentTimeMillis();
        } else {
            Thread.sleep(100); // 休眠避免空循环
        }
    }
    if (!hasMessage) {
        System.out.println("Connection timed out");
        running = false;
        clientSocket.close();
    }
}

4. 完善资源管理 #

客户端退出时，主动停止消息处理线程，避免资源泄漏：

• 在Client类中保存线程实例，退出前调用stopPinging()方法终止线程。

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