Question

I am trying to setup my MessageServer class so that it services each client in a separate request (you’ll see below that it’s pretty linear right now)

How should I go about it?

import java.net.*;
import java.io.*;

public class MessageServer {

public static final int PORT = 6100;

public static void main(String[] args) {

    Socket client = null;
    ServerSocket sock = null;
    BufferedReader reader = null;

    try {
        sock = new ServerSocket(PORT);
        // now listen for connections
        while (true) {
            client = sock.accept();

            reader = new BufferedReader(new InputStreamReader(client.getInputStream()));

            Message message = new MessageImpl(reader.readLine());

            // set the appropriate character counts
            message.setCounts();

            // now serialize the object and write it to the socket
            ObjectOutputStream soos = new ObjectOutputStream(client.getOutputStream());
            soos.writeObject(message);
            System.out.println("wrote message to the socket");

            client.close();
        }
    }
    catch (IOException ioe) {
            System.err.println(ioe);
    }


}

}

Answer 1

Sorry, but your question doesn’t make much sense.

If we are using the term “request” in the normal way, a client sends a request to the server and the server processes each request. It simply makes no sense for a server to not service the requests separately (in some sense).

Perhaps you are asking something different. (Do you mean, “service each client request in a separate thread”?) Whatever you mean, please review your terminology.

---

Given that you are talking about executing requests in different threads, then using the ExecutorService API is a good choice. Use an implementation class that allows you to put an upper bound on the number of worker threads. If you don’t, you open yourself up for problems where overload results in the allocation of large numbers of threads, which only makes the server slower. (Besides, creating new threads is not cheap. It pays to recycle them.)

You should also consider configuring your executor so that it doesn’t have a request queue. You want the executor service to block the thread that is trying to submit the job if there isn’t a worker available. Let the operating system queue incoming connections / requests at the ServerSocket level. If you queue requests internally, you can run into the situation where you are wasting time by processing requests that the client-side has already timed out / abandoned.