CODEWITHSUNDEEP
javamultithreadingconcurrencyioobjectoutputstream
escudero380
escudero380

Reputation: 586

Should I synchronize ObjectOutputStream.writeObject(Object)?

I have a server with multiple clients. It uses one server socket and two thread pools for receiving and handling requests from remote clients: one pool - for handling clients connections, and another one - for processing clients remote tasks. Each client sends asynchronous tasks with unique task ID (within each connection) and a bunch of parameters. Upon task deserialization, the server looks up the corresponding service, invokes the given method on it, wraps the result along with the task ID into the answer object and sends it back to the client using ObjectOutputStream.

Since tasks are handled concurrently, two or more threads might finish processing tasks for one client at the same time and try to compete for the ObjectOutputStream.

What happens next? I mean, do they write their objects to output stream atomically or should I synchronize their access to ObjectOutputStream, so that to avoid situation when one thread writes half of its object - then another thread intervenes and... as a result, a sort of Frankenstein object will be send to the client. 

import java.io.*;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;
import java.util.concurrent.*;

public class Server {

    private final ExecutorService connExecutor = Executors.newCachedThreadPool();  
    private final ExecutorService tasksExecutor = Executors.newCachedThreadPool(); 

    public void start() {
        try (ServerSocket socket = new ServerSocket(2323);) {
            while (true) {
                try (Socket conn = socket.accept()) {
                    connExecutor.execute(() -> {
                        try (ObjectInputStream in = new ObjectInputStream(conn.getInputStream());
                             ObjectOutputStream out = new ObjectOutputStream(conn.getOutputStream())) {
                            while (true) {
                                RemoteTask task = (RemoteTask) in.readObject();
                                tasksExecutor.execute(() -> {
                                    handleTask(task, out);
                                });
                            }
                        } catch (IOException | ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                    });
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void handleTask(RemoteTask task, ObjectOutputStream out) {
        RemoteAnswer answer = new RemoteAnswer();
        // unwrap remote task 
        // lookup local service 
        // invoke task's method
        // wrap result into remote answer

        // send answer to the client 
        try {
            out.writeObject(answer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Upvotes: 0

Views: 764

Answers (2)

GhostCat
GhostCat

Reputation: 140613

This here says it nicely:

Is writing an object to an ObjectOutputStream a thread-safe operation?

Absolutely not.

So, yes, your code needs to take precautions itself.

Upvotes: 1

Quaffel
Quaffel

Reputation: 1493

As a rule of thumb: If the documentation doesn't specify that a certain class is thread-safe, it probably isn't. Thread-safety clearly is an "intentional quality" (allusion to Roman Elizarov's blog post, one of Kotlin's language designers) and should therefore always be mentioned.

However, if you're still unsure whether a class of the Java SE-library provides thread-safety or not (as it might be mentioned somewhere else, e.g. the superclass' documentation), you might also just take a quick glance at the type's source code. As you can see, ObjectOutputStream doesn't implement any synchronization mechanisms.

Upvotes: 0

Related Questions