使用线程和套接字获取服务器响应

Question

我正在构建一个连接到服务器并发送消息的客户端。我已经关闭了那部分，服务器正在获取消息，但我遇到的问题是让我的客户端监听来自服务器的消息。从本质上讲，它就像一个聊天室，我必须在其中向服务器发送消息，而我的客户端还需要从服务器接收消息并在服务器发送消息时将它们打印出来。

我没有构建服务器，也没有访问服务器代码，但我知道服务器工作正常。下面是我为客户端提供的，SendThread 工作得很好，但是当我添加一个 GetThread 时，发送线程不再工作，所以我无法让 2 个线程工作，一个监听一个发送。

Client.java

public class Client {
    public static void main(String[] args) throws IOException {

        // String name = args[0];
        String name = "Brandon";
        Socket socket = new Socket("localhost", 4688);
        Thread sendThread = new SendThread(socket, name);
        Thread getThread = new GetThread(socket);
        sendThread.start();
        getThread.start();
    }
}

SendThread.java

public class SendThread extends Thread {
    Socket socket;
    String name;
    SendThread(Socket s, String n) {
        socket = s;
        this.name = n;
    }

    public void run(){
        try{
            String message;
            PrintWriter printWriter = new PrintWriter(socket.getOutputStream(), true);
            printWriter.println("connect Brandon");
            BufferedReader bufferedReaderFromClient = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println(bufferedReaderFromClient.readLine());
            BufferedReader bufferedReader = new java.io.BufferedReader(new InputStreamReader(System.in));
            while(true) {
                String readerInput = bufferedReader.readLine();
                printWriter.println(name + ": " + readerInput);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

GetThread.java

public class GetThread extends Thread {
    Socket socket;

    GetThread(Socket s) {
        socket = s;
    }

    public void run(){
        try{
            String message;
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while((message = bufferedReader.readLine()) != null) {
                System.out.println("Incoming: " + message);
            }
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

Answer 1

不要创建第二个BufferedReader。在插座的整个生命周期中使用相同的。您正在丢失第一个读取器已经缓冲的数据。

如果readLine() 返回 null，您需要跳出读取循环。

Answer 2

看起来像一个竞争条件。 readLine() 在发送消息之前一直处于阻塞状态，当发生这种情况时，GetThread 或 SendThread 将抓住它，让另一个再次等待。如果您在两个线程中都需要消息，为避免并发问题，您应该考虑使用监视器：

public class Monitor {
    private String msg;
    private boolean hasMsg = false;

    public synchronized void newMsg(String msg) {
        this.msg = msg;
        hasMsg = true;
        notifyAll();
    }

    public synchronized String getMsg() {
        try {
            while (!hasMsg) wait();
        } catch (InterruptedException e) {};

        hasMsg = false;
        return msg;
    }
}

public class Client {
    // ...
    Monitor m = new Monitor();
    Thread sendThread = new SendThread(m, socket, name);
    Thread getThread = new GetThread(m, socket);
    // ...
}

public class GetThread extends Thread {
    private Monitor monitor;
    private Socket socket;
    public GetThread(Monitor m, Socket s) {
        monitor = m;
        socket = s;
    }

    public void run() {
        // ...
        while((message = bufferedReader.readLine()) != null) {
            monitor.newMsg(message);
            System.out.println("Incoming: "+message);
        }
        // ...
    }
}

public class SendThread extends Thread {
    private Socket socket;
    private Monitor monitor;
    private String name;
    public SendThread(Monitor m, Socket s, String n) {
        monitor = m;
        socket = s;
        name = n;
    }

    public void run() {
        // ...
        String readerInput = monitor.getMsg();
        printWriter.println(name + ": "+readerInput);
        // ...
    }
}