How to send multiple of asynchronous requests from client to server

Server side

The server should not handle requests on it's main thread. Instead it should open handling thread for each request it gets.

We should limit the number of concurrent running threads.

Here is simple code example:

public class Server {
    private static final int NUMBER_OF_CONCURRENT_THREADS = 20;
    private ServerSocket serverSocket;
    ExecutorService executor = Executors.newFixedThreadPool(NUMBER_OF_CONCURRENT_THREADS);

    public void start(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        while (true) {

            final Socket clientSocket = serverSocket.accept();
            final ClientHandler clientHandler = new ClientHandler(clientSocket);
            executor.submit(clientHandler);
        }
    }

    public void stop() throws IOException {
        serverSocket.close();
    }

    private static class ClientHandler implements Runnable {
        private Socket clientSocket;

        public ClientHandler(Socket socket) {
            this.clientSocket = socket;
        }

        public void run() {
            // Implement your client logic here
        }
    }
}

Client side

Now you can send your request from the client side concurrently and they will be processed by the service concurrently (up to 20 requests at once)

I'll leave to you the implementation of the concurrent request sending, but here are some guidelines:

• you can send each request in it's own thread, use ExecutorService to handle those threads
• For each response from the service, add to shared variable holding the total sum of all responses.
• Make sure to synchronize access to the shared total sum as multiple threads will be updating it in parallel.

Asynchronous means sending message and not waiting for response.

//Get the response message from server - so you wait whole 5 seconds for response :)
String responseMessage = reader.readLine();

The simplest solution in this case is to remove waiting for response each time. So, get rid of above lines from loop inside Client class.

In this particular client-sever case you do not need additional threads, if you would perform asynchronous things inside one application, then so. Take a look at Java Futures with some tutorial on how to use them. But if you want to get a result from server, you have to wait anyway. And you want to get results of all calcuations. Hence, you have to store all incoming requests somewhere. Simple, naive and impractical, but showing asynchronicity concept code may look like this

public class Client {
  public static void main(String[] args) throws IOException {
    try {
        long start = System.currentTimeMillis();
        BufferedReader reader = null;
        for(int i = 0 ; i < 20; i++){
            Socket s = new Socket("localhost", 7777);
            PrintWriter writer = new PrintWriter(s.getOutputStream());
            InputStreamReader streamReader = new InputStreamReader(s.getInputStream());
            reader = new BufferedReader(streamReader);
            // just make sure you send data and do not wait for response
            System.out.println("Sending " + i  + " : " + (System.currentTimeMillis() - start)); 
            writer.println(i);
            writer.flush();
        }
        //this line works like future.get(), it hangs client until it receives result
        String responseMessage = reader.readLine();
        // process returned data as you want
        System.out.println(responseMessage);
    }
    catch (IOException ex) {
        ex.printStackTrace(); // (**)
    }
  }
}

public class Server {
  public static void main(String[] args) throws IOException {
    try {
        //Make a ServerSocket to listen for message
        ServerSocket ss = new ServerSocket(7777);
        Socket s;
        //we need to store incoming requests to process, and return them
        List<String> integerList = new LinkedList<>();

        while (true) {
            s = ss.accept();

            InputStreamReader streamReader = new InputStreamReader(s.getInputStream());
            BufferedReader reader = new BufferedReader(streamReader);
            String message = reader.readLine();
            System.out.println(message);
            // do something here
            
            Thread.sleep(5000);

            PrintWriter writer = new PrintWriter(s.getOutputStream());
            integerList.add(message);
            writer.println(integerList);
            writer.close();
        }
    } catch (IOException | InterruptedException ex) {
        System.out.println(ex);
    }
  }
}