这个类可以是线程安全的延迟加载，还是像“双重检查锁定”一样不安全？

Question

示例代码如下

public class Lazy<T> implements Supplier<T> {

    public Lazy(Supplier<T> supplier) {
        this.supplier = Objects.requireNonNull(supplier);
    }

    Supplier<T> supplier;

    T value;

    @Override
    public T get() {
        if (supplier != null) {
            synchronized (this) {
                if (supplier != null) {
                    value = supplier.get();
                    supplier = null;
                }
            }
        }
        return value;
    }
}

我担心如果“供应商”是一个构造函数。 “supplier=null”可以在对象初始化之前执行。可能会出现类似于“双重检查锁定损坏”的错误。

"supplier.get()==null" 在这个类中可能为真。所以我不检查值是否为空

如果它是线程不安全的，我应该在“供应商”字段之前添加“volatile”吗？ 如果它是线程安全的，为什么？

Answer 1

这有点复杂，但请阅读this。简而言之，没有 volatile，这就坏了。整个构造可以大大简化：

public class Lazy<T> implements Supplier<T> {
    
     private final Supplier<T> supplier;

     volatile boolean computed = false;

     T value;

     public Lazy(Supplier<T> supplier) {
          this.supplier = Objects.requireNonNull(supplier);
     }

     @Override
     public T get() {
          if (!computed) {
                synchronized (this) {
                   if (!computed) {
                        value = supplier.get();
                        computed = true;
                   }
                }
           }

        return value;
     }

}

Answer 2

问题是，理论上，您无法控制供应商.get() 将返回什么。它可能为空，每次都可能是不同的值，等等。因此，我声称这段代码不是线程安全的。另请注意，“供应商”只有在他们这样做时才会为空：

new Lazy(null)

否则它永远不会为空。这种情况你不妨在构造函数中抛出异常

    public Lazy(Supplier<T> supplier) {
        if (supplier == null) {
            throw new IllegalArgumentException("'supplier' must not be null");
        }
        this.supplier = supplier;
    }

我不确定您要在这里实现什么。如果您想懒惰地初始化“值”，只需一次，您可以执行以下操作：

if (value == null) {
    synchronize (this) {
        // test again to ensure no other thread initialized as we acquired monitor
        if (value == null) {
            value = supplier.get();
        }
    }
}

return value;