java中带有volatile的单例

Question

class MyClass
{
      private static volatile Resource resource;

      public static Resource getInstance()
      {
            if(resource == null)
                  resource = new Resource();
            return resource;
      }
 }

如果您使用易失性，安全发布发生（即，一旦引用对另一个线程可见，数据也可用），我的怀疑是在实践中根据 java 并发性。那么我可以在这里使用它吗？但如果它是正确的，那么假设 thread1 现在检查“资源”并且它为空，因此它开始创建对象。当 thread1 创建对象时，另一个线程即 thread2 来并开始检查“resource”的值，thread2 发现它为 null（假设创建“resource”对象需要相当长的时间，并且由于 thread1 尚未完成创建，所以安全发布没有发生，因此 thread2 不可用）那么它也会开始创建对象吗？如果是，则类不变量中断。我对么？请在这里帮助我理解 volatile 的这种特殊用法。

Answer 1

你是对的，多个线程可以尝试创建一个 Resource 对象。 Volatile 只是保证如果一个线程更新了引用，所有其他线程都会看到新的引用，而不是一些缓存的引用。这更慢，但更安全。

如果您只需要一个延迟加载的资源，则需要执行以下操作：

class MyClass
{
      private static volatile Resource resource;
      private static final Object LOCK = new Object();

      public static Resource getInstance()
      {
            if(resource == null) { 
                synchronized(LOCK) { // Add a synch block
                    if(resource == null) { // verify some other synch block didn't
                                           // write a resource yet...
                        resource = new Resource();
                    }
                }
            }
            return resource;
      }
 }

Answer 2

volatile 解决了一个问题，即可见性问题。如果您正在写入一个声明为 volatile 的变量，那么该值将立即对其他线程可见。众所周知，我们在 os L1、L2、L3 中有不同级别的缓存，如果我们在一个线程中写入变量，则不能保证对其他线程可见，因此如果我们使用 volatile，它会写入直接内存并且是可见的给别人。但是 volatile 并不能解决 原子性 的问题，即 int a; a++; 不安全。因为有三个机器指令与之关联。

Answer 3

我知道您不是在询问更好的解决方案，但如果您正在寻找一个惰性单例解决方案，这绝对值得。

使用私有静态类来加载单例。在调用之前不会加载该类，因此在该类加载之前不会加载引用。通过实现加载类是线程安全的，并且您也产生非常少的开销（如果您正在执行重复的易失性加载[这可能仍然很便宜]，此解决方案在初始构造后总是正常加载）。

class MyClass {
    public static Resource getInstance() {
        return ResourceLoader.RESOURCE;
    }

    private static final class ResourceLoader {
        private static final Resource RESOURCE = new Resource();
    }
}

Answer 4

我认为，您应该在getInstance 定义之前使用syncronized 关键字。

为了获得更好的性能，您可以使用双重检查锁定模式：

• Double-checked locking and the Singleton pattern on IBM
• Double-checked locking on Wiki

Answer 5

当应用于字段时，Java volatile 保证：

1. （在所有 Java 版本中）读取有全局排序 并写入 volatile 变量。这意味着每个线程 访问 volatile 字段将在之前读取其当前值 继续，而不是（可能）使用缓存值。 （然而， 无法保证 volatile 读取的相对顺序 并以常规读写方式进行写入，这意味着它是 通常不是有用的线程构造。）

2. （在 Java 5 或更高版本中）易失性读写建立一个 发生之前的关系，就像获取和释放一个 互斥体。

更多info.

Answer 6

您是对的，在这种情况下，由于您描述的种族，资源可能会被构造两次。如果您想在 Java 5+ 中实现单例（没有显式锁定），请使用What is an efficient way to implement a singleton pattern in Java? 的答案中描述的枚举单例。

Answer 7

volatile 关键字保证对该变量的读写是原子的。

根据tutorial

Reads and writes are atomic for all variables declared volatile

使用 volatile 变量可降低内存一致性的风险 错误，因为对 volatile 变量的任何写入都会建立 与后续读取相同的发生之前的关系 多变的。这意味着对 volatile 变量的更改总是 对其他线程可见。更重要的是，这也意味着当一个 线程读取一个 volatile 变量，它看到的不仅仅是最新的变化 易变的，还有导致代码的副作用 变化。

Answer 8

首先，以这种方式拥有一个单例，您实际上是在创建一个全局对象，这是一种不好的做法。我认为您使用 Enums 代替。

Answer 9

这是我将 volatile 和 synchronized 一起添加的建议。

注意：我们仍然需要仔细检查。

public class MySingleton {
    private static volatile MySingleton instance;
    private MySingleton() {}

    synchronized private static void newInstance() {
        if(instance == null) {
            instance = new MySingleton();
        }
    }

    public static MySingleton get() {
        if(instance == null) {
            newInstance();
        }
        return instance;
    }
}