如何使用多线程从套接字读取请求

Question

I have the following piece of code that reads a string from the socket and processes it. After reading the string from the socket, I am creating a new thread to process the request. This way, I can have multiple threads concurrently processing the incoming requests.

public void process(Socket socket) throws Exception {
    while (true) {
        String request = readFromSocket(socket);
        new Thread(() -> {
            try {
                System.out.println(request); // [edit]: I had omitted this line before as I thought it would be irrelevant
                response = processRequest(request); // <-- request could get modified
            } catch (Exception e) {
                // TODO: Log error and print stack-trace
            }
        }).start();
    }
}

The problem here is, "request" could get modified before a new thread starts processing it. I am new to multi-threading and I read few sites covering the basics. I am still not sure of how to solve the problem here.

Using synchronized to wait until the new thread finishes processing the request would kill the purpose of multithreading. Once I get the request, I want to send it to a new thread so that it can start processing the request, while the parent thread can read the next request.

Any help on how I can solve this problem? Thanks!

[edit after Luke's answer]

In my scenario, the request would be a file name. You could get several requests based on the size of a directory. When I tried my code on a directory with fewer files, everything was fine. But when I ran my code against a directory with thousands of files, things got weird.

Say after readFromSocket, Thread-1 has request X and and Thread-2 has request Y. But inside processRequest(), Thread-1 starts processing request Y.

Answer 1

The problem here is, "request" could get modified before a new thread starts processing it.

No this is not permitted by the Java language.

You don't need to worry about request being modified before it's processed by a new thread. Because, Thread.start() establish a happens-before relationship between the assignment to the request variable and the processRequest(request) method call in the new thread.

When a statement invokes Thread.start, every statement that has a happens-before relationship with that statement also has a happens-before relationship with every statement executed by the new thread. The effects of the code that led up to the creation of the new thread are visible to the new thread.

So this statement String request = readFromSocket(socket); happens before new Thread(...).start(); and whatever code executed by the new thread.

Also String is immutable, so it won't change once it's created. You are safe.

That being said. You are better off using a thread pool for handling requests.

ExecutorService executorService = Executors.newFixedThreadPool(100);

while (true) {
    String request = readFromSocket(socket);
    Runnable task = () -> {
        processRequest(request);
    };
    executorService.submit(task);
}

Similarly, the call to ExecutorService.submit creates a happens-before relationship between whatever happens before it and any statements in the task.

Answer 2

There are various problems with your code.

As you figured yourself, it isn't ideal that one thread P produces something that might be consumed, or not consumed by another thread before P produces a new result.

Thus simply storing the value like you do is bad practice. The reasonable answer is: use a data structure that is designed to allow for "one thread puts something in, other threads take things out"; like the ArrayBlockingQueue .

Then: it is a huge waste of time to create a thread for one job, to then throw it away.

Instead: create an ExecutorService , and submit tasks into that service. The service can be based on a pool of threads, that get re-used; instead of thrown away.