收发TCP同时发送

Question

我正在尝试创建一个发送和接收消息的 TCP 客户端/服务器。 我现在的问题是我不能同时做这两个。 我正在向服务器发送一条消息并很好地阅读它，但是在每条收到消息到服务器之后，我还想向客户端发送一个响应以确认它。

我每秒向服务器发送几条消息，但是当我尝试向客户端重新发送一条消息时，它只是卡住了，两端都没有消息。 但是，我可以向任一方向发送，客户端到服务器和服务器到客户端，但只有一种方式。

这是服务器的客户端处理程序：

public TCPClientHandler(Socket client, int bufferSize) throws IOException {
    this.client = client;
    messageToClient = new PrintWriter(client.getOutputStream(),true);
    recvFromClient = new BufferedReader(new InputStreamReader(client.getInputStream()));
    buffer = new byte[bufferSize];
}
    
@Override
public void run() {
    try {
        /* Read the data from the client.
         * If the message is larger than the server buffer we close the connection.
         * If the client closes connection we get exception and we catch it
         * at the end.
         */
        while (true) {
            if (recvFromClient.readLine().getBytes().length > buffer.length){
                break;
            }
            /* Receiving and printing message */
            buffer = Arrays.copyOf(recvFromClient.readLine().getBytes(),
                recvFromClient.readLine().getBytes().length);
    
            String messageFromClient = new String(buffer,StandardCharsets.UTF_8);
            System.out.println("Client message: " + messageFromClient);
            messageToClient.println();
    
            /* Sending message to client */
        }
    
    } catch (IOException e) {
        System.out.println("Connection to client lost...");
    } finally {
        System.out.println("Connection closed on thread " + Thread.currentThread().getName());
        messageToClient.close();
        try {
            recvFromClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }            
}

这是客户端：

public class TCPEchoClient {

    /*
    Args input
    1. Server Address
    2. Server Port
    3. Socket Buff Size
    4. Transfer Rate
    5. Message
     */
    public void run(String args[]){
        try {
            // Dummy values
            InetAddress host = InetAddress.getByName("localhost");
            int serverPort = 4950;
            int buffSize = 100;
            int transferRate = 5;
            String echoMessage = "112312451265214126531456234321";
            String receive;

            System.out.println("Connection to server on port " + serverPort);

            Socket socket = new Socket(host,serverPort);
            socket.setReceiveBufferSize(buffSize);
            System.out.println("Just connected to " + ocket.getRemoteSocketAddress());

            // Writer and Reader to write and read to/from the socket.
            PrintWriter writeToServer = new PrintWriter(socket.getOutputStream(),true);

            BufferedReader recvFromServer = new BufferedReader(new `InputStreamReader(socket.getInputStream()));`

            if (transferRate < 1){
                writeToServer.println(echoMessage);
            }else {
                // Continuously send messages with 1 second between x amount of
                // messages, until client is aborted.
                while (true) {
                    for (int i = 0; i < transferRate; i++) {
                        writeToServer.println(echoMessage);
                        receive = new String(recvFromServer.readLine().getBytes(), StandardCharsets.UTF_8);
                        System.out.println(receive);
                    }
                    Thread.sleep(1000);
                }
            }

            // Close reader/writer and socket
            writeToServer.close();
            recvFromServer.close();
            socket.close();

        } catch (SocketException e){
            System.out.println("Socket exception...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        TCPEchoClient client = new TCPEchoClient();
        client.run(args);
    }
}

我想读取作为字节传输的消息，将它们存储在缓冲区中，然后读取消息，但到目前为止没有成功。

Answer 1

修复了问题。 我将客户端内部的接收部分移动到线程睡眠之后。