單例的實現有很多種，大部分人其實還是用的 synchronized
目錄
-
synchronized 懶漢式單例
public class Singleton { private static Singleton instance=null; private Singleton() { } public synchronized static Singleton getInstance(){ if (instance == null) { instance = new Singleton(); } return instance; } } #這種方式效率比較低，性能不是太好，不過也可以用， 因爲是對整個方法加上了線程同步，其實只要在new的時候考慮線程同步就行了 ，這種方法不推薦使用。 *****************邪惡的分割線************************** public class Singleton { private static Singleton instance; private final static Object syncLock = new Object(); private Singleton() { } public static Singleton getInstance(){ if (instance == null) { synchronized (syncLock) { if (instance == null) { instance = new Singleton(); } } } return instance; } } 上面兩種都是單例的實現方式
2.java 餓漢式單例
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
餓漢式在 類加載的時候就初始化了，一次是線程安全的，懶漢式不是線程的安全的，因此懶漢式需要配合synchronized關鍵字
你也可以這樣寫餓漢式單例
public class Singleton {
private Singleton instance = null;
static {
instance = new Singleton();
}
private Singleton (){}
public static Singleton getInstance() {
return this.instance;
}
}
或者是下面這樣寫
public class Singleton {
private static class SingletonInite {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonInite.INSTANCE;
}
}
3.用枚舉實現單例（推薦這麼用）
class Singleton {
}
public enum CreateSinleton{
Singleton ;
private Singleton instance;
CreateSinleton() {
//這個是枚舉類的構造方法，反編譯之後對應的是每一個枚舉子項類型的構造方法
instance = new Singleton ();
}
public Singleton getInstance() {
return instance;
}
}
獲取枚舉中的單例：
public class Main {
public static void main(String[] args) {
//CreateSinleton.INSTANCE其實就是獲取枚舉中的INSTANCE類
//INSTANCE.getInstance()其實就是INSTANCE類調用其中的方法，寫在枚舉中的方法，對每一個枚舉元素都是公用的
Singleton singleton = CreateSinleton.INSTANCE.getInstance();
}
}
注意：enum 中的Singleton 反編譯之後是static final 的，這也是爲什麼枚舉在構造法方法中初始化類之後是單例的。
4.CAS自旋實現單例
public class Singleton {
/** CAS 實現 持有 單例實例的引用，CAS 技術保證原子性，AtomicReference 持有引用的變量使用 volatile 修飾保證 可見性 */
private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<>();
private Singleton() {}
public static Singleton getInstance() {
for (;;) {
/** 單例實現了 直接返回*/
Singleton singleton = INSTANCE.get();
if (null != singleton) {
return singleton;
}
/** 未創建 單例實例，直接 cas 原子創建 */
singleton = new Singleton();
if (INSTANCE.compareAndSet(null, singleton)) {
return singleton;
}
}
}
}
基於CAS實現單例的優缺點
用CAS的好處在於不需要使用傳統的鎖機制來保證線程安全,CAS是一種基於忙等待的算法,依賴底層硬件的實現,相對於鎖它沒有線程切換和阻塞的額外消耗,可以支持較大的並行度。
CAS的一個重要缺點在於如果忙等待一直執行不成功(一直在死循環中),會對CPU造成較大的執行開銷。另外，如果N個線程同時執行到singleton = new Singleton();的時候，會有大量對象創建，很可能導致內存溢出。