Java线程安全兼谈DCL

要说清楚这个问题，得先说明一下 JMM 啊，内存模型不摆出来，这个问题永远只能是争个你死我活...

[1]如果thread2执行getInstance()在(2)处发现instance为null，对getInstance()的返回结果继续调用getSomeField()将得到什么？会得到0吗？
因为在调用构造方法时，thread2做了赋值，而且是做了同步操作的，如果调用的线程本身有做同步操作或者是在同一线程那么可以得到确定的值，如果调用的线程是别的线程且未做同步操作那么值是不确定的，因为从头到尾该线程都未取得该对象的锁，因此无法保证它能获得最新的值
[2]DCL为什么要double check，能不能去掉(4)处的check？若不能，为什么？
不能去掉，因为在（2）执行的时候，如果已经进行了判断，之后另外一个线程进行了操作有可能使instance不为null

是因为thread2在调用getPos()时,curX有0,1或2三种可能，同样curY也有0,1或2三种可能，所以getPos()可能返回[0,1], [0,2], [0,3], [1,0], [1,1], [1,2], [2,0], [2,1], [2,2]共九种可能

[0,3]应为[0,0]吧

怎样解释《Java并发编程设计原则与模式》中的这几句话呢？



永远只是在更新对象的成员变量时加锁？

LZ的结论是：

public void draw(Graphics g) {
  int lx, ly;
  synchronized(this) { lx = x; ly = y; }
  g.drawRect(lx, ly, 10, 10);
}

有一点不明白

public static LazySingleton getInstance() { 
        if (instance == null) {                               // (2) 
            synchronized(LazySingleton.class) {               // (3) 
                if (instance == null) {                       // (4) 
                    instance = new LazySingleton();           // (5) 
                } 
            } 
        } 
        return instance;                                      // (6) 
    } 
thread2如果通过2判断 instance == null 进入4 lz说会读到最新的值

我不明白在没有赋值的情况下为什么instance的值会变动？？？？？？
谁在这个过程中赋值了？难道是锁？

还是没有说明谁给instance  赋值了。。。
进锁之前是null 进锁之后又不是null

thread2读取x的值可能为0，1122334400112233外，还可能为别的完全意想不到的值。一种情况假设jvm对long的写入是先写低4位，再写高4位，那么读取到x的值还可能为112233。

The Java Memory Model requires fetch and store operations to be atomic, but for nonvolatile long and double variables, the JVM is permitted to treat a 64-bit(位) read or write as two separate 32-bit operations. If the reads and writes occur in different threads, it is therefore possible to read a nonvolatile long and get back the high 32 bits of one value and the low 32 bits of another

还是那句话，进锁之前后instance的值没有变化，只是进锁前看到的陈旧值，进锁后看到的是最新值，希望你已经明白了。

这里是不是弄错了，我翻了下《java并发编程实践》。

如果thread2执行getInstance()在(2)处发现instance为null，对getInstance()的返回结果继续调用getSomeField()将得到什么？会得到0吗？

在java 5中多增加了一条happen-before规则：
    * 对volatile字段的写操作happen-before后续的对同一个字段的读操作。
利用这条规则我们可以将instance声明为volatile，即：
    private volatile static LazySingleton instance; 
根据这条规则，我们可以得到，线程Ⅰ的语句(5) -> 语线程Ⅱ的句(2)，根据单线程规则，线程Ⅰ的语句(1) -> 线程Ⅰ的语句(5)和语线程Ⅱ的句(2) -> 语线程Ⅱ的句(7)，再根据传递规则就有线程Ⅰ的语句(1) -> 语线程Ⅱ的句(7)，这表示线程Ⅱ能够观察到线程Ⅰ在语句(1)时对someFiled的写入值，程序能够得到正确的行为。

   1. public static LazySingleton getInstance() { 
   2.     if (instance == null) {                                         // (4) 
   3.         synchronized(LazySingleton.class) {                         // (5) 
   4.             if (instance == null) {                                 // (6) 
   5.                 LazySingleton localRef = new LazySingleton(); 
   6.                 instance = localRef;                        // (7) 
   7.             } 
   8.         } 
   9.     } 
  10.     return instance;                                                // (8) 
  11. }