在所有线程的同步块中初始化 static 变量，读取时不同步

Question

I often see the following pattern. One thread will initialize the client in init() method in synchronized block. All the other threads, also called init() method before they start to use the other class methods. Client value is not changed after initialization. They dont set the client value as volatile.

My question is that if this is correct to do? Do all of the threads that create client, and call init() method, will after init method finished see the correct initilized value that was initialized byt the first thread that called init() method?

public class DB {

  private static Object lock = new Object();
  private static Client client;

  public init() {

    synchronized (lock) {
      if (client != null) {
        return;
      }
      client = new Client();
    }
  }

  public insert(Object data) {
    client.insert(data); // is this ok to access the client without volatile or synchronized?
  }
}

The rationale behind that pattern is that they think that because they read the client under synchronized block in init() method, the client will be set to the correct initialized value, and because the client is never changed, they can use it without volatile or synchronized after. IS this correct assumption?

You can see this pattern for example here: https://github.com/brianfrankcooper/YCSB/blob/cd1589ce6f5abf96e17aa8ab80c78a4348fdf29a/mongodb/src/main/java/site/ycsb/db/MongoDbClient.java where they initialized the database in init method and used it without synchronization after.

Answer 1

It is only safe to do this if you are guaranteed to have called init() before calling insert(data) .

There is a happens-before edge created by the synchronized block: the end of the synchronized block happens before the next invocation of the same block.

This means that if a thread has invoked init() , then either:

• client was previously uninitialized, so it is initialized on this call.
• client was previously initialized, and the write to client is has happened before the current thread enters the synchronized block.

No further synchronization is then necessary, at least with respect to client .

However, if a thread doesn't call init() , then there are no guarantees as to whether client is initialized; and no guarantee as to whether the client initialized by another thread (one that did call init() ) will be visible to the current thread (the one that didn't call init() ).

Relying on clients to call init() first is brittle. It would be much better either to use an eagerly-initialized field:

public class DB {

  private static final Client client = new Client();

  public insert(Object data) {
    client.insert(data);  // Guaranteed to be initialized once class loading is complete.
  }
}

or, if you must do it lazily, use a lazy holder:

public class DB {
  private static class Holder {
    private static final Client client = new Client();
  }

  public insert(Object data) {
    Holder.client.insert(data);  // Holder.client is initialized on first access.
  }
}

Or, of course, chuck in a call to init() inside the insert method:

  public insert(Object data) {
    init();
    client.insert(data);
  }

The disadvantage of the latter approach is that all threads must synchronize. In the other two approaches, there is no contention after the first invocation.

Answer 2

It looks like the rationale behind this type of pattern is to ensure that you can only have one instance of Client in the application. Multiple invocations (parallel/sequential) of init() method on different/same DB objects will not allow creating a new Client if it is already created and synchronized block is just to ensure that client object will be created only once if multiple threads called init() parallelly.

But it has nothing to do with safe call of insert() method on client object and that totally depends on the implementation of the insert() method that may be thread-safe or may not be.