Java线程：如何在代码中找到正确的位置，为允许多个客户端连接到服务器的程序创建新线程

Question

I'm creating two program files (one client one server). The client code has to be able to create multiple clients to connect to the server (there is only one server, there can be a multiple and/or infinite number of clients). One new thread has to be created for each client that connects to the server. The way to create a client will be opening a new command prompt / mac terminal window and run the client file. Once a client is connected, it can send messages to the server. It will also receive from the server all messages sent from the other connected clients.

We will focus on the client code for now. (no server code yet)

In the following code there are two places where I created new threads, I am not sure which place it should be located because there are no errors when I run the program in eclipse.

import java.io.*;
import java.net.*;
import java.util.*;
import static java.nio.charset.StandardCharsets.*;
public class ChatClient
{
    private static Socket Socket;
    static int numberOfClients = 0;
    public static void main(String args[]) 
    {


          //If I wanted to create multiple clients, would this code go here? OR should the new thread creation be outside the while(true) loop?
          while (true)
          {
              try 
              {
                  String host = "localhost";
                  InetAddress address = InetAddress.getByName(host);
                  numberOfClients += 1;
                  Thread ChatClient1 = new Thread ()
                  {
                      public void run()
                      {   
                          ServerSocket serverSocket = null;
                          Socket socket = null;
                          try 
                          {
                              int numberofmessages = 0;
                              String[] messagessentbyotherclients = null;
                              System.out.println("Try block begins..");
                              System.out.println("Chat client is running");
                              String port_number1= args[0];
                              System.out.println("Port number is: " + port_number1);
                              int port = Integer.valueOf(port_number1);
                              System.out.println("Listening for connections..");
                              System.out.println( "Listening on port: " + port_number1 );
                              serverSocket = new ServerSocket(port);
                              for(int i = 0; i < numberOfClients; i++)
                              {
                                  System.out.println(messagessentbyotherclients);
                              }
                          }
                          catch (IOException e)
                          {
                              e.printStackTrace();
                          }
                      }
                  };
                  ChatClient1.start();
        }
        catch (IOException e)
        {
            System.out.println("I/O error: " + e);
        }
    }
}

} My question is: Should the thread be created right underneath the main function or inside the while(true) loop? (the while true loop will eventually be exited by control D in standard input)

Answer 1

Your code is so far from a working solution, that I don't think commenting on it is helpful to you at this point. As people in comments have already explained you should have 2 executables for client and server. What you do right now is to spawn server threads in the inner loops without any chance of creating more than one client that connects to the same server.

The usual way to write a multi-threaded client/server app using one thread per client is to write a server-executable, which opens a ServerSocket , which does accept and spawns a new Thread to handle the client-socket in a loop.

Then you write a client-executable, which uses a Socket to connect to the server (on the port used to spawn the server), and talks to the server.

Communication can be done using the input/output streams you get from the sockets at both ends of the connection.

This looks a lot like homework, so I won't provide working code, but you can try to follow these steps:

• Make two classes with a main-method each
• In one class create a Socket , which calls connect to the server. Try to send the simplest possible message from the client, such as a line containing "hello world". PrintWriter can eg be used to wrap the OutputStream of the socket in a more convenient interface.
• In the other class create a ServerSocket and call accept in a loop, handing the returned Socket s to new Thread s, which loop over the input from the client until a terminating signal is received from the client or the connection is closed (IOException). You can start with reading line by line by wrapping the InputStream in a BufferedReader and just printing what the client sends.
• Ensure communication works both ways by sending/receiving responses (Server writes response to OutputStream of the socket associated with the client, client reads InputStream of it's socket)
• Implement your application's protocol over the connection

When you are done, you first start the server, then run as many clients against it as you want. The server needs to be started first, because the connect call will internally open a connection, which can only be completed, if a server is listening on the port the client connects to. If the threading is complicated at all for you, try writing a server that just accepts a connection, then reads a line from it, and closes it before adding the threaded logic. From your code it seems to me like you don't seem to fully understand how a client/server-connection works. Right now you can't even have one client, because - all other issues aside - you call neither accept nor connect .