2. 程式人生 > >單列模式

單列模式

阿新 • • 發佈：2017-05-09
接口 寫法 加載器 exc subjects close 鎖定 itl 新的

首頁 資訊 精華 論壇 問答 博客 專欄 群組 更多 ▼ 知識庫搜索 您還未登錄 ! 登錄 註冊

cantellow

  • 博客
  • 微博
  • 相冊
  • 收藏
  • 留言
  • 關於我
cantellow

單例模式的七種寫法

博客分類：
  • 設計模式
多線程JVMServletIBMIDEA

轉載請註明出處：http://cantellow.iteye.com/blog/838473

第一種（懶漢，線程不安全）：

Java代碼
  1. public class Singleton {
  2. private static Singleton instance;
  3. private Singleton (){}
  5. public static Singleton getInstance() {
  6. if (instance == null) {
  7. instance = new Singleton();
  8. }
  9. return instance;
  10. }
  11. } 
public class Singleton {
    private static Singleton instance;
    private Singleton (){}

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

這種寫法lazy loading很明顯，但是致命的是在多線程不能正常工作。

第二種（懶漢，線程安全）：

Java代碼
  1. public class Singleton {
  2. private static Singleton instance;
  3. private Singleton (){}
  4. public static synchronized Singleton getInstance() {
  5. if (instance == null) {
  6. instance = new Singleton();
  7. }
  8. return instance;
  9. }
  10. } 
public class Singleton {
    private static Singleton instance;
    private Singleton (){}
    public static synchronized Singleton getInstance() {
	if (instance == null) {
	    instance = new Singleton();
	}
	return instance;
    }
}

這種寫法能夠在多線程中很好的工作，而且看起來它也具備很好的lazy loading，但是，遺憾的是，效率很低，99%情況下不需要同步。

第三種（餓漢）：

Java代碼
  1. public class Singleton {
  2. private static Singleton instance = new Singleton();
  3. private Singleton (){}
  4. public static Singleton getInstance() {
  5. return instance;
  6. }
  7. } 
public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton (){}
    public static Singleton getInstance() {
	return instance;
    }
}

這種方式基於classloder機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，雖然導致類裝載的原因有很多種，在單例模式中大多數都是調用getInstance方法， 但是也不能確定有其他的方式（或者其他的靜態方法）導致類裝載，這時候初始化instance顯然沒有達到lazy loading的效果。

第四種（餓漢，變種）：

Java代碼
  1. public class Singleton {
  2. private Singleton instance = null;
  3. static {
  4. instance = new Singleton();
  5. }
  6. private Singleton (){}
  7. public static Singleton getInstance() {
  8. return this.instance;
  9. }
  10. } 
public class Singleton {
    private Singleton instance = null;
    static {
	instance = new Singleton();
    }
    private Singleton (){}
    public static Singleton getInstance() {
	return this.instance;
    }
}

表面上看起來差別挺大，其實更第三種方式差不多，都是在類初始化即實例化instance。

第五種（靜態內部類）：

Java代碼
  1. public class Singleton {
  2. private static class SingletonHolder {
  3. private static final Singleton INSTANCE = new Singleton();
  4. }
  5. private Singleton (){}
  6. public static final Singleton getInstance() {
  7. return SingletonHolder.INSTANCE;
  8. }
  9. } 
public class Singleton {
    private static class SingletonHolder {
	private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}
    public static final Singleton getInstance() {
	return SingletonHolder.INSTANCE;
    }
}

這種方式同樣利用了classloder的機制來保證初始化instance時只有一個線程，它跟第三種和第四種方式不同的是（很細微的差別）：第三種和第四種方式是只要Singleton類被裝載了，那麽instance就會被實例化（沒有達到lazy loading效果），而這種方式是Singleton類被裝載了，instance不一定被初始化。因為SingletonHolder類沒有被主動使用，只有顯示通過調用getInstance方法時，才會顯示裝載SingletonHolder類，從而實例化instance。想象一下，如果實例化instance很消耗資源，我想讓他延遲加載，另外一方面，我不希望在Singleton類加載時就實例化，因為我不能確保Singleton類還可能在其他的地方被主動使用從而被加載，那麽這個時候實例化instance顯然是不合適的。這個時候，這種方式相比第三和第四種方式就顯得很合理。

第六種（枚舉）：

Java代碼
  1. public enum Singleton {
  2. INSTANCE;
  3. public void whateverMethod() {
  4. }
  5. } 
public enum Singleton {
    INSTANCE;
    public void whateverMethod() {
    }
}

這種方式是Effective Java作者Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還能防止反序列化重新創建新的對象，可謂是很堅強的壁壘啊，不過，個人認為由於1.5中才加入enum特性，用這種方式寫不免讓人感覺生疏，在實際工作中，我也很少看見有人這麽寫過。

第七種（雙重校驗鎖）：

Java代碼
  1. public class Singleton {
  2. private volatile static Singleton singleton;
  3. private Singleton (){}
  4. public static Singleton getSingleton() {
  5. if (singleton == null) {
  6. synchronized (Singleton.class) {
  7. if (singleton == null) {
  8. singleton = new Singleton();
  9. }
  10. }
  11. }
  12. return singleton;
  13. }
  14. } 
public class Singleton {
    private volatile static Singleton singleton;
    private Singleton (){}
    public static Singleton getSingleton() {
	if (singleton == null) {
	    synchronized (Singleton.class) {
		if (singleton == null) {
		    singleton = new Singleton();
		}
	    }
	}
	return singleton;
    }
}

這個是第二種方式的升級版，俗稱雙重檢查鎖定，詳細介紹請查看：http://www.ibm.com/developerworks/cn/java/j-dcl.html

在JDK1.5之後，雙重檢查鎖定才能夠正常達到單例效果。

總結

有兩個問題需要註意：

1.如果單例由不同的類裝載器裝入，那便有可能存在多個單例類的實例。假定不是遠端存取，例如一些servlet容器對每個servlet使用完全不同的類裝載器，這樣的話如果有兩個servlet訪問一個單例類，它們就都會有各自的實例。

2.如果Singleton實現了java.io.Serializable接口，那麽這個類的實例就可能被序列化和復原。不管怎樣，如果你序列化一個單例類的對象，接下來復原多個那個對象，那你就會有多個單例類的實例。

對第一個問題修復的辦法是：

Java代碼
  1. private static Class getClass(String classname)
  2. throws ClassNotFoundException {
  3. ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
  5. if(classLoader == null)
  6. classLoader = Singleton.class.getClassLoader();
  8. return (classLoader.loadClass(classname));
  9. }
  10. } 
private static Class getClass(String classname)    
                                         throws ClassNotFoundException {   
      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();   
    
      if(classLoader == null)   
         classLoader = Singleton.class.getClassLoader();   
    
      return (classLoader.loadClass(classname));   
   }   
}

對第二個問題修復的辦法是：

Java代碼
  1. public class Singleton implements java.io.Serializable {
  2. public static Singleton INSTANCE = new Singleton();
  4. protected Singleton() {
  6. }
  7. private Object readResolve() {
  8. return INSTANCE;
  9. }
  10. } 
public class Singleton implements java.io.Serializable {   
   public static Singleton INSTANCE = new Singleton();   
    
   protected Singleton() {   
      
   }   
   private Object readResolve() {   
            return INSTANCE;   
      }  
}

對我來說，我比較喜歡第三種和第五種方式，簡單易懂，而且在JVM層實現了線程安全（如果不是多個類加載器環境），一般的情況下，我會使用第三種方式，只有在要明確實現lazy loading效果時才會使用第五種方式，另外，如果涉及到反序列化創建對象時我會試著使用枚舉的方式來實現單例，不過，我一直會保證我的程序是線程安全的，而且我永遠不會使用第一種和第二種方式，如果有其他特殊的需求，我可能會使用第七種方式，畢竟，JDK1.5已經沒有雙重檢查鎖定的問題了。

========================================================================

總結的很到位：

不過一般來說，第一種不算單例，第四種和第三種就是一種，如果算的話，第五種也可以分開寫了。所以說，一般單例都是五種寫法。懶漢，惡漢，雙重校驗鎖，枚舉和靜態內部類。

我很高興有這樣的讀者，一起共勉。

年終總結上的經驗體會（脫水版） | 重構實踐之一
  • 分類:編程語言
  • 相關推薦
參考知識庫
語音識別與合成知識庫 574 關註 | 316 收錄
計算機視覺知識庫 1339 關註 | 252 收錄
自然語言理解和處理知識庫 491 關註 | 87 收錄
知識工程知識庫 157 關註 | 74 收錄
評論
第三種稍微有點Java基礎就知道是錯的，被瞎寫誤導別人，復制粘貼也要動一下腦子 第四種，靜態方法中是不能用this的吧。。 這樣的： 還有一種利用JVM的類加載機制，
它是線程安全的，同時又是在用到的時候才會創建（利用了java虛擬機的類加載特性）
Java代碼
  1. public class ManagerHolder {
  3. public static Manager managerHolder = new Manager();
  5. }
  7. public class Manager {
  9. public static Manager getInstances() {
  10. return ManagerHolder.managerHolder;
  11. }
  12. } 
public class ManagerHolder {

    public static Manager managerHolder = new Manager();
    
}

public class Manager {

    public static Manager getInstances() {
        return ManagerHolder.managerHolder;
    }
}
52 樓 Mr.Cheney 2015-08-28 還有一種利用JVM的類加載機制，
它是線程安全的，同時又是在用到的時候才會創建（利用了java虛擬機的類加載特性）
Java代碼
  1. public class ManagerHolder {
  3. public static Manager managerHolder = new Manager();
  5. }
  7. public class ManagerHolder {
  9. public static Manager managerHolder = new Manager();
  11. } 
public class ManagerHolder {

    public static Manager managerHolder = new Manager();
    
}

public class ManagerHolder {

    public static Manager managerHolder = new Manager();
    
}
第四種明顯有問題嘛，靜態代碼塊裏可以訪問非靜態變量？靜態方法裏可以寫this.？這不是忽悠嗎，你編譯能通過的 第四種明顯有問題嘛，靜態代碼塊裏可以訪問非靜態變量？靜態方法裏可以寫this.？這不是忽悠嗎，你編譯能通過的啊
第四種明顯有問題嘛，靜態代碼塊裏可以訪問非靜態變量？靜態方法裏可以寫this.？這不是忽悠嗎，你編譯能通過的啊 有人說雙重校驗沒意義
的確在jdk1.5之前是沒意義
但在jdk的裏程碑版本1.5之後就變得很有意義 而且現在以及被廣泛使用 因為引入了修飾符volatile

這也是為什麽說jdk1.5才能使用雙重校驗 new Singleton() 如果需要傳參數才能實例化怎麽辦？第三種方式 第四種（餓漢，變種）:
如何獲取Singleton的實例？ 我寫的一個單例， 在tomcat6上， 一個servlet put 數據，一個get數據。
在pc 瀏覽器、手機的瀏覽器上都沒有問題， 但是同事寫的一個手機應用，發送請求，就發現單例變成了2個 對象。非常奇怪。不知道有沒有這方面的經歷？？謝謝
估計是類加載器的原因吧，像這種應用，讓web服務器確保單例根本就不合適，多個web服務器更是如此，你可以采用其他方式，比如放在memcache 我寫的一個單例， 在tomcat6上， 一個servlet put 數據，一個get數據。
在pc 瀏覽器、手機的瀏覽器上都沒有問題， 但是同事寫的一個手機應用，發送請求，就發現單例變成了2個 對象。非常奇怪。不知道有沒有這方面的經歷？？ 類是不同的加載器裝載的問題怎麽解決？ 你的這7種方法不錯。不過，最好，每個都加上私有構造方法：防止外部直接 new Singleton() 這樣才能真正保證單例。。
private Singleton(){

} 如果用第三種，建議聲明為final的，因為我們沒有理由不將其聲明為final的。另外，關於雙重鎖定，建議你看看EhCache的源代碼裏的CacheManager類，new了新的實力後，應該在synchronized塊內return，其余一致，包括將實例聲明為原子的。
附EhCache項目CacheManager部分源代碼：
Java代碼
  1. public static CacheManager create() throws CacheException {
  2. if (singleton != null) {
  3. return singleton;
  4. }
  5. synchronized (CacheManager.class) {
  6. if (singleton == null) {
  7. LOG.debug("Creating new CacheManager with default config");
  8. singleton = new CacheManager();
  9. } else {
  10. LOG.debug("Attempting to create an existing singleton. Existing singleton returned.");
  11. }
  12. return singleton; // 這裏是在synchronized塊內返回的，而你的例子不是
  13. }
  14. } 
public static CacheManager create() throws CacheException {
    if (singleton != null) {
        return singleton;
    }
    synchronized (CacheManager.class) {
        if (singleton == null) {
            LOG.debug("Creating new CacheManager with default config");
            singleton = new CacheManager();
        } else {
            LOG.debug("Attempting to create an existing singleton. Existing singleton returned.");
        }
        return singleton; // 這裏是在synchronized塊內返回的，而你的例子不是
    }
}
發表評論

您還沒有登錄,請您登錄後再發表評論

cantellow
  • 瀏覽: 525879 次
  • 性別:
  • 來自:
最近訪客 更多訪客>>
文章分類
  • 全部博客 (75)
  • Java (23)
  • C++ (1)
  • 重構 (2)
  • 質量 (9)
  • JVM (3)
  • 項目管理 (6)
  • 數據庫 (1)
  • 設計模式 (4)
  • 並發 (1)
  • web (5)
  • linux (1)
  • maven (1)
  • IOS開發 (4)
  • 小項目 (1)
  • 書籍是人類進步的階梯 (5)
  • 他山之石可以攻玉 (1)
  • 其他 (9)
  • 逆向 (1
最新評論
  • 60love5： 第三種稍微有點Java基礎就知道是錯的，被瞎寫誤導別人，復制粘 ...
    單例模式的七種寫法
  • Bocurry： 第四種，靜態方法中是不能用this的吧。。
    單例模式的七種寫法
  • Mr.Cheney： 這樣的：<div class="quote_t ...
    單例模式的七種寫法
  • Mr.Cheney： 還有一種利用JVM的類加載機制， 它是線程安全的，同時又是在用 ...
    單例模式的七種寫法
  • tianyi1： 第四種有問題
    單例模式的七種寫法
關閉

單列模式

相關推薦

單列模式

接口 寫法 加載器 exc subjects close 鎖定 itl 新的 首頁 資訊 精華 論壇 問答 博客 專欄 群組 更多 ▼ 知識庫搜索 您還未登錄 ! 登錄 註冊 cantellow 博客 微博 相冊 收藏 留言 關於我

單列模式的介紹

技術 依靠 情況 分享 圖片 補充 單例模式 應用場景 單列 1. 單例模式的作用和應用場景(不全後面補充)？ 1.1保證裏面Java應用程序中，只有一個實例的存在。比如：瀏覽網站顯示當前在線人數，就是用一個單例的對象。 2.單例模式的幾種寫法 2.1註意事項： (1)

JAVA基礎——設計模式之單列模式

因此 style 對象 lba 原子 類型 div 等於 加載 一：單例設計模式 Singleton是一種創建型模式，指某個類采用Singleton模式，則在這個類被創建後，只可能產生一個實例供外部訪問，並且提供一個全局的訪問點。 單例設計模式的特點： 單例類只能有一個實

C#實現單列模式案列

單列模式就是不能夠讓使用者建立多個物件 比如  Form  frm  =  new Form() ，Form  obj1 =  new   Form() ，這裡就建立了兩個Form類的物件 常用的單列模式的建立一

面象物件的反射和單列模式

a ="普通變數a"b ="普通變數b"A ="普通常量A"B ="普通常量B"import sysdef func(): print("func,function")def func1(): print("func1,function")while 1: res = input("<

單列模式之執行緒安全實現

單例模式有五種寫法：懶漢、餓漢、雙重檢驗鎖、靜態內部類、列舉   懶漢式執行緒不安全 public class Singleton { private static Singleton instance; private Singleton (){} publ

Kotlin單列模式封裝Retrofit

class RetrofitUtils private constructor() { val C_TIME: Long = 15 val W_TIME: Long = 15 val R_TIME: Long = 15 var retrofit

java單列模式(從0開始分析)

Java中的單例模式的資料已經有很多了，很優秀的也有許多，但是我的部落格，還是為小白寫的。（因為我也是小白啊！）希望你可以按我的步驟一起學習一下，我已經寫的很詳細了，寫一遍大於看一遍！！！如果你是大神也不要緊，你可以直接看這篇部落格（我大部分想法都來源於他），或者幫我看看我有

單列模式與多執行緒

　在23個標準設計模式中，單例模式在應用中還是很常見的，但是在多執行緒環境中，單例模式的使用有非常多的坑，使用好單例模式的一個原則：如何使單例模式在遇到多執行緒的環境中是安全的、正確的。下面分析幾種多執行緒的實現方式以及遇到的坑。 一、立即載入/餓漢模式 　　立即載入：實用類的時候已經將物件

java單列模式

1 懶漢式 public class SingletonTest1 { private static SingletonTest1 single = null; //懶漢式 public static SingletonTest1 getInstane(){ if(null ==

java設計模式——單列模式

單列模式           定義：  在一個應用程式中單列模式的類有且只有一個例項，單列模式中又分為兩種，餓漢模式和懶漢模式。    一、餓漢模式           定義：餓漢模式，是在類載入的時候便建立例項，所謂餓漢，即表示這個類很飢渴，需要快速得到類的例項，所以在類加

Java設計模式思想（單列模式，工廠模式，策略模式，共23種設計模式）

a) 單例模式：單例模式核心只需要new一個例項物件的模式，    比如資料庫連線，線上人數等，一些網站上看到的線上人數統計就是通過單例模式實現的，    把一個計時器存放在資料庫或者記憶體中，當有人登陸的時候取出來加一再放回去，    有人退出登陸的時候取出來減一再放回去，

單列模式導致記憶體洩漏

Android中常見的記憶體洩漏彙總 集合類洩漏 集合類如果僅僅有新增元素的方法，而沒有相應的刪除機制，導致記憶體被佔用。如果這個集合類是全域性性的變數 (比如類中的靜態屬性，全域性性的 map 等即有靜態引用或 final 一直指向它)，那麼沒有相應的刪除

設計模式之單列模式

6.單例模式（Singleton Pattern） 前面說提到的五種建立模式，主要解決的問題是如何建立物件，獲得產品。而單例模式最要關心的則是物件建立的次數以及何時被建立。 Singleton模式可以是很簡單的，它的全部只需要一個類就可以完成（看看這章可憐的UML圖）。但

終於理解單列模式了，單列模式和多執行緒

//1、單例類確保自己只有一個例項(構造方法私有化)//2、單例類必須自己建立自己的例項。//3、單例類必須為其他物件提供唯一的例項。package Singleton;//懶漢式  單例例項在第一次被使用時構建，延遲初始化。public class singleton { 

六、單列模式

public exc HERE 類型 doc light object resolv cti using System; using System.Collections.Generic; using System.Linq; using System.Threa

設計模式 之 單列設計模式

語句 原子性 了解 right 一個 技術分享 設計模式 美的 fin 本文章是在學習了 微信公眾號 “java後端技術 ” 之後自己的學習筆記 。 其中直接 復制了 相當部分的原作者的原文。 　　　　如果您看到了我的這篇文章， 推薦您 查看原文 原文連接 ：

Java第八天學習筆記～面向物件（陣列工具、單列設計模式、繼承）

    陣列工具 1，陣列工具物件建立 class ArrayToolDemo { /*保證程式的獨立執行*/ public static void main(String[] args) { int[] arr={4,8,2,9,72,6}; //

python單列設計模式總結

主要作用：如建立音樂播放器 物件，回收站 物件，印表機 物件，在系統中只有一個唯一的例項 就是不管建立多少次同一個物件，他們的地址永遠都是一樣的。 主要使用：__new__方法（分配空間的） 使用類名（）建立物件時，python的直譯器會 首先 呼叫 __new__方法為物件 分配

黑馬程式設計師---單列設計模式

---------------------- android培訓、java培訓、期待與您交流！ ---------------------- 設計模式  單例設計模式：保證類在記憶體中只有一個物件。    如何保證類在記憶體中只有一個物件呢？  (1)控制類的建立，不讓