单例模式

//代码引自Java设计模式,我自己稍有改动

public class Factory{
    private static Factory factory;
    
    private long wipMoves;

    private Factory(){
        wipMoves=0;
    }

    public static Factory getFactory(){
        synchronized(Factory.class){//这里能不能用this？？？
             if(factory==null)
        　　　　　　factory=new Factory();
        　　　return factory;
        }
    }
}

 1 public class Resource {
 2 
 3     private static Resource resource ;
 4     
 5     public static Resource getInstance(){
 6         
 7         if(resource == null ){
 8             synchronized (Resource.class) {
 9                 if(resource  == null ){
10                     resource  = new Resource() ;
11                 }
12             }
13             
14         }
15         
16         return resource ;
17     }
18     
19     private Resource(){}
20 
21 }

当一个域声明为volatile类型后，编译器与运行时会监视这个变量：它是共享的，而且对它的操作不会与其他的内存操作一起被重排序。
volatile变量不会缓存在寄存器或缓存在对其他处理器隐藏的地方。所以，读一个volatile类型的变量时，总会返回由某一线程所写入的最新值。 

 1   public class Singleton {
 2     private static volatile Singleton INSTANCE = null;
 3  
 4     // Private constructor suppresses 
 5     // default public constructor
 6     private Singleton() {}
 7  
 8     //thread safe and performance  promote 
 9     public static  Singleton getInstance() {
10         if(INSTANCE == null){
11              synchronized(Singleton.class){
12                  //when more than two threads run into the first null check same time, to avoid instanced more than one time, it needs to be checked again.
13                  if(INSTANCE == null){ 
14                      INSTANCE = new Singleton();
15                   }
16               } 
17         }
18         return INSTANCE;
19     }
20   }

  public class Singleton {
    private final static Singleton INSTANCE = new Singleton();
 
    // Private constructor suppresses   
    private Singleton() {}
 
    // default public constructor
    public static Singleton getInstance() {
        return INSTANCE;
    }
  }