Question

这是我到目前为止所做的，我是朝着正确的方向前进的吗？目标是在一个线程需要比其他线程更频繁地访问单例的情况下使用它，因此需要无锁代码，我想使用原子变量进行练习。

public final class ThreadSafeLazyCompareAndSwapSingleton {

private ThreadSafeLazyCompareAndSwapSingleton(){}

private static volatile ThreadSafeLazyCompareAndSwapSingleton instance;
private final static AtomicBoolean atomicBoolean = new AtomicBoolean(false);

public static ThreadSafeLazyCompareAndSwapSingleton getCASInstance(){
    if (instance==null){
        boolean obs = instance==null;
        while (!atomicBoolean.compareAndSet(true, obs == (instance==null))){
            instance = new ThreadSafeLazyCompareAndSwapSingleton(); 
        }
    }
    return instance;
}

}

Answer 1

呃，这些内联条件/分配很难阅读。它也是非常标准的习惯用法，所以我想知道你是否真的想要使用它。

至少存在一个问题，即它可以创建多个实例（在您的情况下可能是可接受的，如果您想要无锁，则无法避免这种情况）。但我认为它也可能会返回多个实例，这不是我想要的。

我不确定您是否需要布尔值，您也可以直接在instance字段上使用AtomicReferenceFieldUpdater。

我认为不需要obs，如果可以设置布尔值，你可以创建并返回一个新实例，否则循环：

if (instance!=null)
  return instance;

if (atomicBoolean.compareAndSet(false, true))
{
  instance = new ThreadSafeLazyCompareAndSwapSingleton();
  return instance;
}
while(instance==null);
return instance;

但我真的不认为使用这个额外的布尔值是个好主意。

Answer 2

这样的事情会更安全 - 但有比这更好的方法。

public final class ThreadSafeLazyCompareAndSwapSingleton {

    // THE instance.
    private static volatile ThreadSafeLazyCompareAndSwapSingleton instance;
    // Catches just one thread.
    private final static AtomicBoolean trap = new AtomicBoolean(false);

    public static ThreadSafeLazyCompareAndSwapSingleton getInstance() {
        // All threads will spin on this loop until instance has been created.
        while (instance == null) {
            // ONE of the spinning threads will get past the trap. Probably the first one.
            if ( trap.compareAndSet(false, true)) {
                // By definition of CAS only one thread will get here and construct.
                instance = new ThreadSafeLazyCompareAndSwapSingleton();
            }
        }
        // By definition instance can never be null.
        return instance;
    }

    // Dont let anyone but me construct.
    private ThreadSafeLazyCompareAndSwapSingleton() {
    }

}

请注意，如果在构造期间抛出异常，则会失败。

Answer 3

这里一个好的心理方法是将线程分为两类：可以实例化类的那些，以及不能实例化的类。（为简明扼要，我会将班级名称简化为Singleton）。然后你必须考虑每个类别的线程需要做什么：

实例化线程需要存储它们在instance中创建的引用并将其返回
所有其他线程需要等到设置instance，然后将其返回

此外，我们需要确保两件事：

实例化和所有返回（包括非实例化线程中的返回）之间存在一个先发生的边缘。这是为了线程安全。
实例化线程集合只有一个元素（假设任何一个集合都是非空的，当然）。这是为了确保只有一个实例。

好的，这些是我们的四个要求。现在我们可以编写满足它们的代码。

private final AtomicBoolean instantiated = new AtomicBoolean(false);
private static volatile Singleton instance = null;
// volatile ensures the happens-before edge

public static Singleton getInstance() {
    // first things first, let's find out which category this thread is in
    if (instantiated.compareAndSet(false, true) {
        // This is the instantiating thread; the CAS ensures only one thread
        // gets here. Create an instance, store it, and return it.
        Singleton localInstance = new Singleton();
        instance = localInstance;
        return localInstance;
    } else {
        // Non-instantiating thread; wait for there to be an instance, and
        // then return it.
        Singleton localInstance = instance;
        while (localInstance == null) {
            localInstance = instance;
        }
        return localInstance;
    }
}

现在，让我们相信我们的每一个条件都得到满足：

实例化线程会创建一个实例，存储它并返回它：这是CAS的“真实”块。
其他线程等待设置实例，然后返回：这就是while循环的作用。
在实例化和返回之间存在一个before-before（HB）边缘：对于实例化线程，线程内语义可以确保这一点。对于所有其他线程，volatile关键字确保写入（在实例化线程中）和读取（在此线程中）之间的HB边缘
假设调用该方法，实例化线程的集合正好一个：第一个命中CAS的线程将返回true;所有其他人都将返回假。

所以我们都准备好了。

这里的一般建议是将您的要求细分为尽可能具体的子要求。然后你可以单独解决每个问题，这更容易推理。

这个实现是否适用于Java中的无锁线程安全懒惰单例？

3 个答案: