package com.paddx.test.concurrent;

public class Singleton {
  public static volatile Singleton singleton;

  /**
   * 构造函数私有，禁止外部实例化
   */
  private Singleton() {};

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

package com.paddx.test.concurrent;

public class VolatileTest {
  int a = 1;
  int b = 2;

  public void change(){
    a = 3;
    b = a;
  }

  public void print(){
    System.out.println(\"b=\"+b+\";a=\"+a);
  }

  public static void main(String[] args) {
    while (true){
      final VolatileTest test = new VolatileTest();
      new Thread(new Runnable() {
        @Override
        public void run() {
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          test.change();
        }
      }).start();

      new Thread(new Runnable() {
        @Override
        public void run() {
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          test.print();
        }
      }).start();

    }
  }
}

...... 
b=2;a=1
b=2;a=1
b=3;a=3
b=3;a=3
b=3;a=1
b=3;a=3
b=2;a=1
b=3;a=3
b=3;a=3
......

17.7 Non-Atomic Treatment of double and long 
For the purposes of the Java programming language memory model, a single write to a non-volatile long or double value is treated as two separate writes: one to each 32-bit half. This can result in a situation where a thread sees the first 32 bits of a 64-bit value from one write, and the second 32 bits from another write.

Writes and reads of volatile long and double values are always atomic. 

Writes to and reads of references are always atomic, regardless of whether they are implemented as 32-bit or 64-bit values. 

Some implementations may find it convenient to divide a single write action on a 64-bit long or double value into two write actions on adjacent 32-bit values. For efficiency\'s sake, this behavior is implementation-specific; an implementation of the Java Virtual Machine is free to perform writes to long and double values atomically or in two parts. 

Implementations of the Java Virtual Machine are encouraged to avoid splitting 64-bit values where possible. Programmers are encouraged to declare shared 64-bit values as volatile or synchronize their programs correctly to avoid possible complications.

package com.paddx.test.concurrent;

public class VolatileTest01 {
  volatile int i;

  public void addI(){
    i++;
  }

  public static void main(String[] args) throws InterruptedException {
    final VolatileTest01 test01 = new VolatileTest01();
    for (int n = 0; n < 1000; n++) {
      new Thread(new Runnable() {
        @Override
        public void run() {
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          test01.addI();
        }
      }).start();
    }

    Thread.sleep(10000);//等待10秒，保证上面程序执行完成

    System.out.println(test01.i);
  }
}

Two actions can be ordered by a happens-before relationship.If one action happens before another, then the first is visible to and ordered before the second.

• Each action in a thread happens before every subsequent action in that thread. 
• An unlock on a monitor happens before every subsequent lock on that monitor. 
• A write to a volatile field happens before every subsequent read of that volatile. 
• A call to start() on a thread happens before any actions in the started thread. 
• All actions in a thread happen before any other thread successfully returns from a join() on that thread. 
• If an action a happens before an action b, and b happens before an action c, then a happens before c.

package com.paddx.test.concurrent;

public class MemoryBarrier {
  int a, b;
  volatile int v, u;

  void f() {
    int i, j;

    i = a;
    j = b;
    i = v;
    //LoadLoad
    j = u;
    //LoadStore
    a = i;
    b = j;
    //StoreStore
    v = i;
    //StoreStore
    u = j;
    //StoreLoad
    i = u;
    //LoadLoad
    //LoadStore
    j = b;
    a = i;
  }
}