双重检查锁定物品

Question

我正在阅读关于“双重检查锁定”的这篇文章在文章的主题之外，我想知道为什么在文章的某些时候作者使用了下一个习语：

清单 7. 尝试解决乱序写入问题

public static Singleton getInstance()   
  { 
      if (实例 == null) 
      { 
          同步（Singleton.class）{//1 
              单例inst=实例；   //2 
              if (inst == null) 
              { 
                  同步（Singleton.class）{//3 
                      inst = new Singleton();   //4 
                  } 
                  实例=实例；   //5 
              } 
          } 
      } 
      返回实例； 
  } 
  

我的问题是： 是否有任何理由使用同一个锁同步两次某些代码？ 这有什么目的吗？

提前谢谢了。

Answer 1

遵循 John Skeet 建议：

但是，要深入探讨这个主题
我推荐 Bill Pugh 的文章。 和
那就永远不要尝试:)

这是第二个同步块的关键：

这段代码构建了
内部的辅助对象
同步块。 直观的想法
这里应该有一个记忆
障碍点处
同步被释放，并且
应防止重新排序
Helper 对象的初始化
以及对该字段的分配
帮手。

因此，基本上，使用内部同步块，我们试图“欺骗”JMM 在同步块内创建实例，以强制 JMM 在同步块完成之前执行该分配。 但这里的问题是，JMM 正在引导我们，并将同步块之前的分配移到同步块内，将我们的问题移回到开头。

这是我从这些文章中了解到的，非常有趣，再次感谢您的回复。

Answer 2

好吧，但是文章说

由于内存模型的当前定义，清单 7 中的代码不起作用。 Java 语言规范 (JLS) 要求同步块内的代码不得移出同步块。 但是，它并没有说不在同步块中的代码不能移动到同步块中。

而且似乎 JVM 还对 ASM 中的“伪代码”进行了下一个翻译：

public static Singleton getInstance() 
  { 
    if (实例 == null) 
    { 
      同步（Singleton.class）{//1 
        单例inst=实例；   //2 
        if (inst == null) 
        { 
          同步（Singleton.class）{//3 
            //inst = new Singleton();   //4 
            实例=新单例（）；                
          } 
          //实例=实例；   //5 
        } 
      } 
    } 
    返回实例； 
  } 
  

到目前为止，“instance=inst”之后的不写入点还没有实现吗？

我现在将阅读这篇文章，感谢您的链接。

Answer 3

从 Java 5 开始，您可以通过将字段声明为 volatile 来进行双重检查锁定。

请参阅 http://www.cs.umd.edu/~pugh /java/memoryModel/DoubleCheckedLocking.html 以获得完整的解释。

Answer 4

关于这个习惯用法，有一篇非常建议和澄清的文章：

http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html?page=1

另一方面，我认为 dhighwayman.myopenid 的意思是为什么作者将一个引用同一类 (synchronized(Singleton.class)) 的同步块放在引用同一类的另一个同步块中。 当在该块内创建一个新实例（Singleton inst = instance;）时，可能会发生这种情况，并且为了保证它是线程安全的，有必要编写另一个同步。

否则我看不出任何意义。

Answer 5

请参阅有关 Java 内存模型的 Google 技术讲座，了解更精细的内容JMM 的要点。 由于这里缺少它，我还想指出 Jeremy Mansons 博客 'Java Concurrency' 特别是。 关于双重检查锁定的帖子（任何在Java 世界似乎有一篇关于此的文章:)。

Answer 6

对于 Java 5 及更高版本，实际上有一个双重检查变体，它比同步整个访问器更好。 双重检查锁定声明中也提到了这一点：

class Foo {
    private volatile Helper helper = null;
    public Helper getHelper() {
        if (helper == null) {
            synchronized(this) {
                if (helper == null)
                    helper = new Helper();
            }
        }
        return helper;
    }
}

这里的关键区别是在变量声明中使用易失性 - 否则它不起作用，并且无论如何它在Java 1.4或更低版本中不起作用。

Answer 7

锁定两次的目的是尝试防止乱序写入。 内存模型指定了重新排序可以发生的位置，部分是通过锁来实现的。 该锁确保在“instance = inst;”之后不会出现任何写入操作（包括单例构造函数内的任何写入操作）。 线。

然而，为了更深入地探讨这个主题，我推荐 Bill Pugh 的文章。 然后永远不要尝试:)

Answer 8

本文指的是 5.0 之前的 Java 内存模型 (JMM)。 在该模型下，留下同步块会强制写入主内存。 因此，这似乎是为了确保 Singleton 对象在引用它之前被推出。 然而，它并不太有效，因为对实例的写入可以向上移动到块 - roach motel 中。

然而，5.0 之前的模型从未正确实现。 1.4应该遵循5.0模型。 类是惰性初始化的，所以你最好只写

public static final Singleton instance = new Singleton();

或者更好，不要使用单例，因为它们是邪恶的。

Answer 9

Jon Skeet 是对的：请阅读 Bill Pugh 的 文章。 汉斯使用的习语是不起作用的精确形式，因此不应使用。

这是不安全的：

private static Singleton instance;

public static Singleton getInstance() {
  if (instance == null) {
    synchronized(Singleton.class) {
      if (instance == null) {
        instance = new Singleton();
      }
    }
  }
  return instance;
}

这也是不安全的：

public static Singleton getInstance()  
{
    if (instance == null)
    {
        synchronized(Singleton.class) {      //1
            Singleton inst = instance;         //2
            if (inst == null)
            {
                synchronized(Singleton.class) {  //3
                    inst = new Singleton();        //4
                }
                instance = inst;                 //5
            }
        }
    }
    return instance;
}

永远不要做其中任何一个。

相反，同步整个方法：

    public static synchronized Singleton getInstance() {
      if (instance == null) {
        instance = new Singleton();
      }
      return instance;
    }

除非您每秒检索该对象无数次，否则实际上对性能的影响可以忽略不计。

Answer 10

我在这里介绍了一些内容：

http://tech.puredanger .com/2007/06/15/double-checked-locking/