// thread 1
class Singleton {
    private static Singleton INSTANCE

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton() // new物件
                }
            }
        }
        return
 
 INSTANCE;
    }

}

// thread 2
Singleton.getInstance(); // 這裡可能獲取到未建立完整的Singleton物件引用

這個程式碼是無法工作的. 因為這個可能讓其他執行緒看到沒有完全構件好的物件:

JVM建立一個物件的過程來看，分為：“裝載”，“連線”，“初始化”三個步驟。
在連線步驟中包含“驗證”，“準備”，“解析”這幾個環節。
為一個物件分配記憶體的過程是在連線步驟的準備環節，它是先於“初始化”步驟的，而建構函式的執行是在“初始化”步驟中的。

簡單理解，上述INSTANCE = new Singleton()的過程是非原子操作，其實際過程如下：

// 實際上的步驟:
1.allocateMemory -> object 
2.Singleton._INSTANCE = object
3.init object attributes

假如兩個執行緒同時搶奪執行上述程式碼，此時因為執行緒1和執行緒2沒有用同步，他們之間不存在“Happens-Before”規則的約束，所以線上程1建立Singleton物件的 1,2這兩個步驟對於執行緒2來說會有可能出現1可見，2不可見
造成了執行緒2獲取到了一個未建立完整的Singleton物件引用

//其中分析一個物件建立過程的部分摘抄如下[Symantec(賽門鐵克)JIT]：

singletons[i].reference = new
 
 Singleton();
to the following (note that the Symantec JIT using a handle-based object allocation system).

-------
0206106A   mov         eax,0F97E78h         ; allocate space for
0206106F   call        01F6B210             ; Singleton, return result in eax
02061074   mov         dword ptr [ebp],eax       ; EBP is &singletons[i].reference 

02061077   mov         ecx,dword ptr [eax]       ; store the unconstructed object here.

02061079   mov         dword ptr [ecx],100h      ; dereference the handle to
0206107F   mov         dword ptr [ecx+4],200h    ; get the raw pointer
02061086   mov         dword ptr [ecx+8],400h   ; Next 4 lines are
0206108D   mov         dword ptr [ecx+0Ch],0F84030h ; Singleton's inlined constructor

-------

As you can see, the assignment to singletons[i].reference is performed before the constructor for Singleton is called. This is completely legal under the existing Java memory model, and also legal in C and C++ (since neither of them have a memory model).

jdk5以上版本可使用volatitle修復,jdk5以下版本基本無法修復

/*
* @since 1.5
*/
class Singleton {
    private static volatile Singleton INSTANCE

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton() // new物件
                }
            }
        }
        return INSTANCE;
    }

}

附: Doug Lea

public class DoubleCheckTest
  {


  // static data to aid in creating N singletons
  static final Object dummyObject = new Object(); // for reference init
  static final int A_VALUE = 256; // value to initialize 'a' to
  static final int B_VALUE = 512; // value to initialize 'b' to
  static final int C_VALUE = 1024;
  static ObjectHolder[] singletons;  // array of static references
  static Thread[] threads; // array of racing threads
  static int threadCount; // number of threads to create
  static int singletonCount; // number of singletons to create


  static volatile int recentSingleton;


  // I am going to set a couple of threads racing,
  // trying to create N singletons. Basically the
  // race is to initialize a single array of 
  // singleton references. The threads will use
  // double checked locking to control who 
  // initializes what. Any thread that does not
  // initialize a particular singleton will check 
  // to see if it sees a partially initialized view.
  // To keep from getting accidental synchronization,
  // each singleton is stored in an ObjectHolder 
  // and the ObjectHolder is used for 
  // synchronization. In the end the structure
  // is not exactly a singleton, but should be a
  // close enough approximation.
  // 


  // This class contains data and simulates a 
  // singleton. The static reference is stored in
  // a static array in DoubleCheckFail.
  static class Singleton
    {
    public int a;
    public int b;
    public int c;
    public Object dummy;

    public Singleton()
      {
      a = A_VALUE;
      b = B_VALUE;
      c = C_VALUE;
      dummy = dummyObject;
      }
    }

  static void checkSingleton(Singleton s, int index)
    {
    int s_a = s.a;
    int s_b = s.b;
    int s_c = s.c;
    Object s_d = s.dummy;
    if(s_a != A_VALUE)
      System.out.println("[" + index + "] Singleton.a not initialized " +
s_a);
    if(s_b != B_VALUE)
      System.out.println("[" + index 
                         + "] Singleton.b not intialized " + s_b);

    if(s_c != C_VALUE)
      System.out.println("[" + index 
                         + "] Singleton.c not intialized " + s_c);

    if(s_d != dummyObject)
      if(s_d == null)
        System.out.println("[" + index 
                           + "] Singleton.dummy not initialized," 
                           + " value is null");
      else
        System.out.println("[" + index 
                           + "] Singleton.dummy not initialized," 
                           + " value is garbage");
    }

  // Holder used for synchronization of 
  // singleton initialization. 
  static class ObjectHolder
    {
    public Singleton reference;
    }

  static class TestThread implements Runnable
    {
    public void run()
      {
      for(int i = 0; i < singletonCount; ++i)
        {
    ObjectHolder o = singletons[i];
        if(o.reference == null)
          {
          synchronized(o)
            {
            if (o.reference == null) {
              o.reference = new Singleton();
          recentSingleton = i;
          }
            // shouldn't have to check singelton here
            // mutex should provide consistent view
            }
          }
        else {
          checkSingleton(o.reference, i);
      int j = recentSingleton-1;
      if (j > i) i = j;
      }
        } 
      }
    }

  public static void main(String[] args)
    {
    if( args.length != 2 )
      {
      System.err.println("usage: java DoubleCheckFail" +
                         " <numThreads> <numSingletons>");
      }
    // read values from args
    threadCount = Integer.parseInt(args[0]);
    singletonCount = Integer.parseInt(args[1]);

    // create arrays
    threads = new Thread[threadCount];
    singletons = new ObjectHolder[singletonCount];

    // fill singleton array
    for(int i = 0; i < singletonCount; ++i)
      singletons[i] = new ObjectHolder();

    // fill thread array
    for(int i = 0; i < threadCount; ++i)
      threads[i] = new Thread( new TestThread() );

    // start threads
    for(int i = 0; i < threadCount; ++i)
      threads[i].start();

    // wait for threads to finish
    for(int i = 0; i < threadCount; ++i)
      {
      try
        {
        System.out.println("waiting to join " + i);
        threads[i].join();
        }
      catch(InterruptedException ex)
        {
        System.out.println("interrupted");
        }
      }
    System.out.println("done");
    }
  }