客户端服务器程序的多线程

Question

我正在尝试使用我一直在努力的客户端/服务器程序实现多线程。 我需要允许多个客户端同时连接到服务器。 我目前有4类：客户端，服务器，协议和用于处理线程的工作器。 以下代码是我对这些类所拥有的：

SocketServer类：

public class SocketServer {


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

        int portNumber = 9987;

        try ( 
            ServerSocket serverSocket = new ServerSocket(portNumber);
            Socket clientSocket = serverSocket.accept();
            PrintWriter out =
                new PrintWriter(clientSocket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()));

        ) {
            Thread thread = new Thread(new ClientWorker(clientSocket));
            thread.start(); //start thread

            String inputLine, outputLine;

            // Initiate conversation with client
            Protocol prot = new Protocol();
            outputLine = prot.processInput(null);
            out.println(outputLine);

            while ((inputLine = in.readLine()) != null) {
                outputLine = prot.processInput(inputLine);
                out.println(outputLine);
                if (outputLine.equals("quit"))
                    break;
            }
        } catch (IOException e) {
            System.out.println("Exception caught when trying to listen on port "
                + portNumber + " or listening for a connection");
            System.out.println(e.getMessage());
        }
    }
}

SocketClient类别：

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

        String hostName = "localhost";
        int portNumber = 9987;

        try (
            Socket socket = new Socket(hostName, portNumber);
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
        ) {
            BufferedReader stdIn =
            new BufferedReader(new InputStreamReader(System.in));
            String fromServer;
            String fromUser;

            while ((fromServer = in.readLine()) != null) {
                System.out.println("Server: " + fromServer);
                if (fromServer.equals("quit"))
                    break;

                fromUser = stdIn.readLine();
                if (fromUser != null) {
                    System.out.println("Client: " + fromUser);
                    out.println(fromUser);
                }
            }
        } catch (UnknownHostException e) {
            System.err.println("Don't know about host " + hostName);
            System.exit(1);
        } catch (IOException e) {
            System.err.println("Couldn't get I/O for the connection to " +
                hostName);
            System.exit(1);
        }
    }
}

协议类别：

public class Protocol {

    private static final int waiting         = 0;
    private static final int sentPrompt      = 1;


    private int status = waiting;

     public String processInput(String theInput) {
         String theOutput = null;

        if (status == waiting) {
            theOutput = "Please enter what you would like to retrieve: 'customer' or 'product' ";
            status = sentPrompt;
        }
        else if ( status == sentPrompt ) {
            if ( theInput.equalsIgnoreCase("product")) {
                File f = new File("product.txt");
                Scanner sc = null;
                try {
                    sc = new Scanner(f);
                } catch (FileNotFoundException ex) {
                    Logger.getLogger(Protocol.class.getName()).log(Level.SEVERE, null, ex);
                }

                while ( sc.hasNextLine()  ) {
                    String line   = sc.nextLine();
                    theOutput = "The current product entries are : " + line;
                }
                return theOutput;
            }
            else if ( theInput.equalsIgnoreCase("customer")) {
                File f = new File("customer.txt");
                Scanner sc = null;
                try {
                    sc = new Scanner(f);
                } catch (FileNotFoundException ex) {
                    Logger.getLogger(Protocol.class.getName()).log(Level.SEVERE, null, ex);
                }

                while ( sc.hasNextLine()  ) {
                    String line   = sc.nextLine();
                    theOutput = "The current customer entries are : " + line;
                }
                return theOutput;

            }
            else if ( theInput.equalsIgnoreCase("quit")) {
                return "quit";
            }
            else {
                return "quit";
            }
        }
        return theOutput;
    }
}

ClientWorker类：

public class ClientWorker implements Runnable {
    private final Socket client;

    public ClientWorker( Socket client ) {
        this.client = client;
    }

    @Override
    public void run() {
        String line;
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            System.out.println("Thread started with name:"+Thread.currentThread().getName());
            in = new BufferedReader(new InputStreamReader(client.getInputStream()));
            out = new PrintWriter(client.getOutputStream(), true);
        } catch (IOException e) {
            System.out.println("in or out failed");
            System.exit(-1);
        }

        while (true) {
            try {
                System.out.println("Thread running with name:"+Thread.currentThread().getName());
                line = in.readLine();
                //Send data back to client
                out.println(line);
                //Append data to text area
            } catch (IOException e) {
                System.out.println("Read failed");
                System.exit(-1);
            }
        }
    }       
}

当我运行服务器和客户端时，一切正常。 然后，当我尝试运行另一个客户端时，它只是挂在那儿，没有提示客户端给出响应。 非常感谢您对我所缺少的任何见解！

Answer 1

您的服务器代码应解决以下功能。

1. 在while循环中继续从ServerSocket接受套接字

2. 通过传递客户端套接字（即套接字 ）在accept（）调用之后创建新线程

3. 在您的情况下，在客户端套接字线程（例如ClientWorker中进行IO处理。

看看这篇文章

您的代码应为

ServerSocket serverSocket = new ServerSocket(portNumber);
while(true){
  try{
    Socket clientSocket = serverSocket.accept();
    Thread thread = new ClientWorker(clientSocket);
    thread.start(); //start thread
  }catch(Exception err){
     err.printStackTrace();
  }
}

Answer 2

serverSocket.accept()被调用多少次？ 一旦。 那就是它将处理多少个客户。 后续尝试联系的客户将没有任何人在听他们的邀请。

要处理更多客户端，您需要循环调用serverSocket.accept() 。