如何保证对对象的所有非线程安全引用都将被同步？

Question

Suppose I have a class:

public final class Server {

private final ArrayList<ServerConnection> connections;
private ServerConnection pending;
private Thread connector;

public Server() {
    connections = new ArrayList<>();

    connector = new Thread(() -> {
        while (true) {
            pending = new ServerConnection();
            pending.waitForConnection();

            //Could be adding while another thread is iterating.
            connections.add(pending);
        }
    }, "Connection Establisher");
    connector.setDaemon(true);
    connector.setPriority(Thread.MIN_PRIORITY);
    connector.start();
}

//Anyone with a refrence to this object can access connections.
public ArrayList<ServerConnection> getConnections() {
    return connections;
}
}

How would I make sure that connections is not in use while I add an object. I thought about using a synchronized (connections) {...} block in the thread but from my knowledge of synchronized blocks all non-thread-safe references to connections would have to be in a synchronized block. Is there some way that I can make sure that all non-thread-safe access to connections are synchronized?

Answer 1

Making the getConnections method synchronized is not enough because once the caller gets a reference to the list, it can do whatever it wants with it, including thread unsafe operations.

A few simple steps would make your code more robust:

• only use final variables
• provide a start and stop method. At the moment you start the thread in the constructor and leak a reference to this - this could have weird visibility effects. And you don't manage the thread stopping, making the thread a daemon instead - it works but is probably not as clean.

A simple rewrite could look like the code below (it can certainly be improved) - check the comments. Note that it would work better if the waitForConnection reacted to interruption appropriately too, for example by throwing an InterruptedException .

public final class Server {

  //us a thread safe list
  private final List<ServerConnection> connections = new CopyOnWriteArrayList<>();
  //make the thread final
  private final Thread connector;

  public Server() {
    connector = new Thread(() -> {
      //provide a mechanism to stop the thread: exit on interruption
      while (!Thread.currentThread().isInterrupted()) { 
        ServerConnection pending = new ServerConnection();
        pending.waitForConnection();

        //Could be adding while another thread is iterating.
        connections.add(pending);
      }
    }, "Connection Established");
    //Note that the priority may be ignored at runtime
    connector.setPriority(Thread.MIN_PRIORITY);
  }

  public void start() {
    connector.start();
  }

  //to stop the thread, interrupt it
  public void stop() {
    if (!connector.isAlive()) throw new IllegalStateException("The server is not started");
    connector.interrupt();
  }

  //don't return the list but an unmodifiable view of the list
  public List<ServerConnection> getConnections() {
    return Collections.unmodifiableList(connections);
  }
}