Design pattern ——singleton pattern(單例基礎)

Talk is cheap  Show me the code

個人學習筆記--僅供參考

餓漢式 1

package pattern;

/**
 * 懶漢式，類被加載的時候，就生成相應對象
 * 這種方式會造成資源浪費，
 * Spring 中IOC 容器ApplicationContext 本身就是典型的餓漢式單例
 * @author qsnp236
 *
 */
public class HungarySingleton {
	/**
	 * 私有構造方法，不允許外部
	 */
	private HungarySingleton() {
	}

	/**
	 * 生成對象
	 */
	private final static HungarySingleton obj = new HungarySingleton();

	/**
	 * 提供外部訪問
	 * 
	 * @return
	 */
	public final static HungarySingleton getInstance() {
		return obj;
	}
}

餓漢式2

package pattern;

/**
 * 懶漢式，類被加載的時候，就生成相應對象
 * 這種方式會造成資源浪費，
 * Spring 中IOC 容器ApplicationContext 本身就是典型的餓漢式單例
 * @author qsnp236
 *
 */
public class HungarySingleton2 {
	private final static HungarySingleton2 obj;
	/**
	 * 私有構造方法，不允許外部
	 */
	private HungarySingleton2() {
	}
	/**
	 *  靜態代碼塊生成對象
	 */
	static {

		obj = new HungarySingleton2();
	}
	

	/**
	 * 提供外部訪問
	 * 
	 * @return
	 */
	public final static HungarySingleton2 getInstance() {

		return obj;
	}
}

懶漢式1

package pattern;
/**
 * 懶漢式  ，在外部調用getInstance的時候，判斷對象是不是空，爲空就去牀架一個，返回，
 * 這種方式在getInstance 時，如果有多個同時調用，會產生兩個對象，可以加鎖
 * @author qsnp236
 *
 */
public class LazySingleton {
    /**
     * 內部初始化函數
     */
	private LazySingleton() {}
	/**
	 * 構造一個空的對象
	 */
	private static LazySingleton obj=null;
	/**
	 * 提供外部訪問
	 * @return
	 */
	public  final static LazySingleton getInstance() {
		//判斷是空的時候調用
		 if(obj==null) {
			 obj=new LazySingleton();
		 }
		 return obj;
	}
}

懶漢式2

package pattern;
/**
 * 懶漢式  ，在外部調用getInstance的時候，判斷對象是不是空，爲空就去牀架一個，返回，
 * 這種方式在getInstance 時，如果有多個同時調用，會產生兩個對象，可以加鎖、
 * 這個是加鎖的方式
 * @author qsnp236
 *
 */
public class LazySingletonLock1 {
    /**
     * 內部初始化函數
     */
	private LazySingletonLock1() {}
	/**
	 * 構造一個空的對象
	 */
	private static LazySingletonLock1 obj=null;
	/**
	 * 提供外部訪問,加鎖
	 * @return
	 */
	public final static synchronized LazySingletonLock1 getInstance() {
		//判斷是空的時候調用
		 if(obj==null) {
			 obj=new LazySingletonLock1();
		 }
		 return obj;
	}
}

懶漢式3

package pattern;
/**
 * 懶漢式  ，在外部調用getInstance的時候，判斷對象是不是空，爲空就去牀架一個，返回，
 * 這種方式在getInstance 時，如果有多個同時調用，會產生兩個對象，可以加鎖、
 * 這個加雙重鎖的方式
 * @author qsnp236
 *
 */
public class LazySingletonLock2 {
    /**
     * 內部初始化函數
     */
	private LazySingletonLock2() {}
	/**
	 * 構造一個空的對象
	 */
	private volatile static LazySingletonLock2 obj=null;
	/**
	 * 提供外部訪問,加鎖
	 * @return
	 */
	public static  LazySingletonLock2 getInstance() {
		//判斷是空的時候調用
		 synchronized (LazySingletonLock2.class) {
		 if(obj==null) {
			
				 obj=new LazySingletonLock2();
			
		 }
		 }
		 return obj;
	}
}

懶漢式3 

package pattern;
/**
 * 懶漢式  ，在外部調用getInstance的時候，判斷對象是不是空，爲空就去牀架一個，返回，
 * 這種方式在getInstance 時，如果有多個同時調用，會產生兩個對象，可以加鎖、
 * 這個是加鎖的方式
 * @author qsnp236
 *
 */
public class LazySingletonDoubleLock {
    /**
     * 內部初始化函數
     */
	private LazySingletonDoubleLock() {}
	/**
	 * 構造一個空的對象
	 */
	private static volatile LazySingletonDoubleLock obj=null;
	/**
	 * 提供外部訪問,加鎖
	 * @return
	 */
	public final static  LazySingletonDoubleLock getInstance() {
		//判斷是空的時候調用
		 synchronized (LazySingletonDoubleLock.class) {
		 if(obj==null) {
			
				 obj=new LazySingletonDoubleLock();
			}
			
		 }
		 return obj;
	}
}

優化版

package pattern;
/**
 * 懶漢式  ，在外部調用getInstance的時候，判斷對象是不是空，爲空就去牀架一個，返回，
 * 這種方式在getInstance 時，如果有多個同時調用，會產生兩個對象，
 * 這個是利用內部類
 * @author qsnp236
 *
 */
public  class LazySingletonInnerClass {
    /**
     * 內部初始化函數
     */
	private LazySingletonInnerClass() {}

	/**
	 * 提供外部訪問
	 * @return
	 */
	public static final LazySingletonInnerClass getInstance() {
		
		 return InnerClass.innerObj;
	}

	
	
	private static class InnerClass{
		
		public static final LazySingletonInnerClass innerObj =new LazySingletonInnerClass();
	
	}
}

看代碼，看註釋