Java併發編程 線程安全下的單例模式

在域上運用延遲初始化佔位類模式

/**
 * 在域上運用延遲初始化佔位類模式
 */
public class InstanceLazy {
	
	private Integer value;
	private Integer heavy;//成員變量很耗資源， ;
	
    public InstanceLazy(Integer value) {
		super();
		this.value = value;
	}

	private static class InstanceHolder{
        public static Integer val = new Integer(100);
    }

	public Integer getValue() {
		return value;
	}

	public Integer getVal() {
		return InstanceHolder.val;
	}

}

懶漢式-雙重檢查

/**
 * 懶漢式-雙重檢查
 */
public class SingleDcl {
    private volatile static SingleDcl singleDcl;
    //私有化
    private SingleDcl(){
    }

    public static SingleDcl getInstance(){
        if (singleDcl == null){ //第一次檢查，不加鎖
            System.out.println(Thread.currentThread()+" is null");
            synchronized(SingleDcl.class){ //加鎖
                if (singleDcl == null){ //第二次檢查，加鎖情況下
                    System.out.println(Thread.currentThread()+" is null");
                    //內存中分配空間  1
                    //空間初始化 2
                    //把這個空間的地址給我們的引用  3
                    singleDcl = new SingleDcl();
                }
            }
        }
        return singleDcl;
    }
}

餓漢式-枚舉

/**
 * 餓漢式
 * 枚舉
 */
public class SingleEHan {
    private SingleEHan(){}
    private static SingleEHan singleDcl = new SingleEHan();

}

懶漢式-延遲初始化佔位類模式

/**
 * 懶漢式-延遲初始化佔位類模式
 */
public class SingleInit {
    private SingleInit(){}

    private static class InstanceHolder{
        private static SingleInit instance = new SingleInit();
    }

    public static SingleInit getInstance(){
        return InstanceHolder.instance;
    }

}

懶漢式 - synchronized 加鎖

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