Java 中帶有 sockets 的多線程服務器和客戶端

Question

我正在嘗試為大學項目創建服務器/從機/客戶端項目。 服務器應該打開 2 個端口，一個端口用於連接從站，另一個端口用於客戶端。

我為客戶端設置了 2 個線程 1，為從屬設置了另一個。 客戶端應該向服務器發送隨機數，服務器應該將這些隨機數轉發給從屬實例。 從站應該檢查當前號碼是否存在於他們的列表中，如果它不能存儲它，否則他們應該向服務器發送一個消息，表明該號碼已經存在。

然后我創建了由 2 個線程組成的客戶端線程，一個用於將數字發送到服務器，另一個線程用於讀取來自服務器的消息。 PrintWriter 的代碼有問題，當代碼在線程內時，我無法將數字發送到服務器。 如果我移動主代碼並取消線程，則發送消息沒有任何問題。 這可能是什么問題？

下面是來自服務器（主）和客戶端的當前代碼。

public class Client {
private static final int NUMBERS = 50;
private static final int AMPLITUDE = 100;
private static int masterPort;

public Client(int port) {
    this.masterPort = port;
}

public static void main(String[] args) throws IOException{
    String serverHostname = "127.0.0.1"; 

    System.out.println("Αναμονή για σύνδεση στον σέρβερ " + serverHostname + " στην πόρτα 30091.");
    Socket echoSocket = null;
    BufferedReader in = null;
    try {
        echoSocket = new Socket(serverHostname, 18889); 
        in = new BufferedReader(new InputStreamReader(echoSocket.getInputStream())); 
    } catch (UnknownHostException e) {
        System.err.println("Δεν μπορεί να πραγματοποιηθεί σύνδεση με τον σέρβερ: " + serverHostname); 
        System.exit(1);
    } catch (IOException e) {
        System.err.println("Couldn't get I/O for the connection to: " + serverHostname); 
        System.exit(1);
    }

    ClientOut clientOut = new ClientOut(echoSocket);
    clientOut.start();
    ClientIn clientIn = new ClientIn(in);
    clientIn.start();

    in.close();
    echoSocket.close();
}

public static class ClientOut extends Thread {
    private PrintWriter out;

    public ClientOut(Socket echoSocket) throws IOException {
        this.out = new PrintWriter(echoSocket.getOutputStream(), true);
    }

    @Override
    public void run() {
        System.out.println("Ο client συνδέθηκε!");
        Random rnd = new Random();
        try {
            for (int i=0; i<NUMBERS; i++) {
                int num = rnd.nextInt(AMPLITUDE);
                System.out.println(num);
                out.println(num);
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (InterruptedException e) {
                e.printStackTrace();
            }
                out.close();
        }
    }


public static class ClientIn extends Thread {
    private BufferedReader in;

    public ClientIn(BufferedReader in) {
        this.in = in;
    }

    @Override
    public void run() {

    }
}

}

public class Master {
private int slavePort;
private int clientPort;
private SlaveThread slaveThread;
private ClientThread clientThread;
private boolean running = false;
public static int slaveConnected; // Slave connection counter

public Master(int slavePort, int clientPort) {
    this.slavePort = slavePort;
    this.clientPort = clientPort;
    this.slaveConnected = 0; 

public void startServer() {
    try {
        this.slaveThread = new SlaveThread(slavePort);
        this.clientThread = new ClientThread(clientPort);
        System.out.println( "Αναμονή για σύνδεση client / slave" );
        slaveThread.start();
        clientThread.start();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void stopServer() {
    running = false;
    this.slaveThread.interrupt();
    this.clientThread.interrupt();

}

class SlaveThread extends Thread {
    private ServerSocket slaveSocket;

    SlaveThread(int slavePort) throws IOException {
        this.slaveSocket = new ServerSocket(slavePort);
    }
    @Override
    public void run() {
        running = true;
        while (running) {
            try {
                // Call accept() to receive the next connection
                Socket slSocket = slaveSocket.accept();
                System.out.println("Δημιουργήθηκε μια νέα σύνδεση Slave");

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

class ClientThread extends Thread {
    private ServerSocket clientSocket;

    ClientThread(int clientPort) throws IOException {
        this.clientSocket = new ServerSocket(clientPort);
    }

    @Override
    public void run() {
        running = true;
        while (running) {
            try {
                Socket clSocket = clientSocket.accept();
                BufferedReader in = new BufferedReader(new InputStreamReader(clSocket.getInputStream()));
                System.out.println("Δημιουργήθηκε μια νέα σύνδεση Client");

                String inputLine;
                while ((inputLine = in.readLine())  != null) {
                    System.out.println("Client: " + inputLine);
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

public static void main(String[] args) {
    Master server = new Master( 30091, 18889);
    server.startServer();
    // Automatically shutdown in 1 minute
    try {
        Thread.sleep( 60000 );
    } catch(Exception e) {
        e.printStackTrace();
    }
    server.stopServer();
}

Answer 1

我找到了解決方案。 Socket 應該在客戶端線程構造函數上創建，而不是作為引用傳遞。 所以客戶端應該是

public class Client {
private static final int NUMBERS = 50;
private static final int AMPLITUDE = 100;
private static int masterPort;

public Client(int port) {
    this.masterPort = port;
}

public static void main(String[] args) throws IOException{
    String serverHostname = "127.0.0.1"; //Ορίζουμε την διεύθυνση που είναι ο σέρβερ

    System.out.println("Αναμονή για σύνδεση στον σέρβερ " + serverHostname + " στην πόρτα 30091.");

    ClientOut clientOut = new ClientOut(serverHostname);
    clientOut.start();
    ClientIn clientIn = new ClientIn(serverHostname);
    clientIn.start();
}

public static class ClientOut extends Thread {
    private Socket echoSocket;
    private PrintWriter writer;

    ClientOut(String serverHostname) throws IOException {
        this.echoSocket = new Socket(serverHostname, 18889);
        this.writer = new PrintWriter(echoSocket.getOutputStream(), true);;
    }

    @Override
    public void run() {
        System.out.println("Ο client συνδέθηκε!");
        Random rnd = new Random();
        try {
            for (int i=0; i<NUMBERS; i++) {
                int num = rnd.nextInt(AMPLITUDE);
                System.out.println(num);
                writer.println(num);
                TimeUnit.SECONDS.sleep(1);
            }
        } catch (InterruptedException e) {
                e.printStackTrace();
            }
        writer.close();
        }
    }