将双重检查锁定从使用同步转换为 JAVA 中的锁定

Question

考虑以下代码在 JAVA 8 中使用 synchronized 关键字实现双重检查锁定：

private static void redoHeavyInitialisation() {
    if (needToReinitialise()) {
        synchronized (MyClass.class) {
            if (needToReinitialise()) {
                doHeavyInitialisation();
            }
        }
    }
}

使用双重检查锁定的原因是因为初始化很繁重（因此很懒）并且它可能发生多次（因此不能使用单例模式，如果我错了，请纠正我）。

无论如何，首先，如何将上面的代码转换为使用 JAVA 并发包中的Lock 而不是使用同步关键字？

仅在此之后 AND 可选，随意评论使用 Lock 或 synchronized 关键字哪个更好。

请记住，这个问题与 Lock 与同步比较无关。没有回答代码转换部分的回答将不会被选为接受的答案。

Answer 1

使用ReentrantLock 将同步块转换为等效块非常简单。

首先，您创建一个与您锁定的对象具有相同或相似范围和生命周期的锁。在这里，您锁定了MyClass.class，因此是一个静态锁，因此您可以将其映射到MyClass 中的静态锁，例如MyClass.initLock。

然后只需替换每个：

synchronized (object) {

与

lock.lock();
try {

以及每个与

关联的右大括号

} finally {
  lock.unlock();
}

把它们放在一起你就有了：

private final static ReentrantLock initLock = new ReentrantLock();

private static void redoHeavyInitialisation() {
    if (needToReinitialise()) {
        MyClass.initLock.lock();
        try {
            if (needToReinitialise()) {
                doHeavyInitialisation();
            }
        } finally {
          MyClass.initLock.unlock();
        }
    }
}

在性能方面，两种方法之间几乎没有日光。它们本质上具有相同的语义，并且通常使用相似的底层机制。过去，存在性能差异 - 有时优化会影响其中一个或另一个，因此在某些 JVM 上您可以找到差异，但双重检查锁定的重点是要避免无论如何都要拿锁，所以只做最简单的事情。在 needToReinitialise() 方法运行时，您只会在非常短的过渡时间内获得锁定，因此锁定成本不会产生任何持续影响。

Answer 2

考虑以下代码：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HeavyInitializer {
static final Logger logger = LoggerFactory.getLogger(HeavyInitializer.class);
static HeavyInitializer singleton;
public static synchronized HeavyInitializer getInstance() {
    if (singleton==null) {
        singleton = new HeavyInitializer();
    }
    return singleton;
}
boolean initialized;
private HeavyInitializer() {
    initialized = false;
}

public synchronized void initialize() {
     if (!initialized) {
         heavyStuffDoneHere();
     }
}
public synchronized void reInitilize() {
    if (needToReinitialise()) {
        heavyStuffDoneHere();
    }
}

private void heavyStuffDoneHere() {
    initialized = true;
}

private boolean needToReinitialise() {
    if (!initialized)
       return false;
    boolean ret = false;
    //Do your check here... and set ret     
    return ret;
}

}

来自Oracle's doc：

...那么使这些方法同步有两个效果：

• 首先，对同一对象的同步方法的两次调用不可能交错。当一个线程正在为一个对象执行同步方法时，所有其他为同一对象调用同步方法的线程都会阻塞（暂停执行），直到第一个线程处理完该对象。

• 其次，当同步方法退出时，它会自动与同一对象的任何后续同步方法调用建立起之前的关系。这保证了对象状态的更改对所有线程都是可见的。

尝试使用 Lock 将尝试重新实现同步块。没有必要。

Answer 3

单例双重检查锁并防止单例对象使用序列化破坏。

包模式.core.java; 导入 java.io.Serializable;

公共类单例扩展对象实现可序列化{

private static final long serialVersionUID = 1L;
private static Singleton sg;

private Singleton() {
}

public static Singleton getSingletonObj() {
    if (sg == null) {
        synchronized (sg) {
            if (sg == null) {
                sg = new Singleton();
            }
        }
    } 
    return sg;
}


/*
 * this method ensures that new object will not be created for singleton
 * class using serialization and deserialization
 */
protected Object readResolve() {
    return sg;
}

/*
 * @Override protected Object clone() throws CloneNotSupportedException {
 * throw new CloneNotSupportedException(); }
 */

@Override
protected Object clone() throws CloneNotSupportedException {
    return sg;
}

}