2. 程式人生 > >Java設計模式(五)：單例設計模式

Java設計模式(五)：單例設計模式

阿新 • • 發佈：2019-01-08

1. 應用場景

一個無狀態的類使用單例模式節省記憶體資源。 比如說執行緒池、快取、對話方塊、設定偏好和登錄檔物件、日誌物件、充當印表機、顯示卡等裝置的驅動程式物件。

2. 概念

確保一個類只有一個例項，並提供該例項的全域性訪問點。

3.Class Diagram

使用一個私有建構函式、一個私有靜態變數以及一個公有靜態函式來實現。

私有建構函式保證了不能通過建構函式來建立物件例項，只能通過公有靜態函式返回唯一的私有靜態變數。

在這裡插入圖片描述

4. Implementation

4.1 懶漢式-執行緒不安全

以下實現中，私有靜態變數 uniqueInstance 被延遲例項化，這樣做的好處是，如果沒有用到該類，那麼就不會例項化 uniqueInstance，從而節約資源。

這個實現在多執行緒環境下是不安全的，如果多個執行緒能夠同時進入 if (uniqueInstance == null) ，並且此時 uniqueInstance 為 null，那麼會有多個執行緒執行 uniqueInstance = new Singleton(); 語句，這將導致例項化多次 uniqueInstance。

public class ChocolateBoiler {
	private boolean empty;
	private boolean boiled;
	private static ChocolateBoiler uniqueInstance;
  
	private
 
 ChocolateBoiler() {
		empty = true;
		boiled = false;
	}
  
	public static ChocolateBoiler getInstance() {
		if (uniqueInstance == null) {
			System.out.println("Creating unique instance of Chocolate Boiler");
			uniqueInstance = new ChocolateBoiler();
		}
		System.out.println("Returning instance of Chocolate Boiler"
 
);
		return uniqueInstance;
	}

	public void fill() {
		if (isEmpty()) {
			empty = false;
			boiled = false;
			// fill the boiler with a milk/chocolate mixture
		}
	}
 
	public void drain() {
		if (!isEmpty() && isBoiled()) {
			// drain the boiled milk and chocolate
			empty = true;
		}
	}
 
	public void boil() {
		if (!isEmpty() && !isBoiled()) {
			// bring the contents to a boil
			boiled = true;
		}
	}
  
	public boolean isEmpty() {
		return empty;
	}
 
	public boolean isBoiled() {
		return boiled;
	}
}

4.2 餓漢式-執行緒安全

執行緒不安全問題主要是由於 uniqueInstance 被例項化多次，採取直接例項化 uniqueInstance 的方式就不會產生執行緒不安全問題。

但是直接例項化的方式也丟失了延遲例項化帶來的節約資源的好處。

public class ChocolateBoiler {
	private boolean empty;
	private boolean boiled;
	private static ChocolateBoiler uniqueInstance =new ChocolateBoiler();
  
	private ChocolateBoiler() {
		empty = true;
		boiled = false;
	}
  
	public ChocolateBoiler getInstance() {
		return uniqueInstance;
	}

	public void fill() {
		if (isEmpty()) {
			empty = false;
			boiled = false;
			// fill the boiler with a milk/chocolate mixture
		}
	}
 
	public void drain() {
		if (!isEmpty() && isBoiled()) {
			// drain the boiled milk and chocolate
			empty = true;
		}
	}
 
	public void boil() {
		if (!isEmpty() && !isBoiled()) {
			// bring the contents to a boil
			boiled = true;
		}
	}
  
	public boolean isEmpty() {
		return empty;
	}
 
	public boolean isBoiled() {
		return boiled;
	}
}

4.3 懶漢式-執行緒安全

只需要對 getUniqueInstance() 方法加鎖，那麼在一個時間點只能有一個執行緒能夠進入該方法，從而避免了例項化多次 uniqueInstance。

但是當一個執行緒進入該方法之後，其它試圖進入該方法的執行緒都必須等待，即使 uniqueInstance 已經被例項化了。這會讓執行緒阻塞時間過長，因此該方法有效能問題，不推薦使用。

public class ChocolateBoiler {
	private boolean empty;
	private boolean boiled;
	private static ChocolateBoiler uniqueInstance;
  
	private ChocolateBoiler() {
		empty = true;
		boiled = false;
	}
  
	public synchronized static ChocolateBoiler getInstance() {
		if (uniqueInstance == null) {
			System.out.println("Creating unique instance of Chocolate Boiler");
			uniqueInstance = new ChocolateBoiler();
		}
		System.out.println("Returning instance of Chocolate Boiler");
		return uniqueInstance;
	}

	public void fill() {
		if (isEmpty()) {
			empty = false;
			boiled = false;
			// fill the boiler with a milk/chocolate mixture
		}
	}
 
	public void drain() {
		if (!isEmpty() && isBoiled()) {
			// drain the boiled milk and chocolate
			empty = true;
		}
	}
 
	public void boil() {
		if (!isEmpty() && !isBoiled()) {
			// bring the contents to a boil
			boiled = true;
		}
	}
  
	public boolean isEmpty() {
		return empty;
	}
 
	public boolean isBoiled() {
		return boiled;
	}
}

4.4 雙重校驗鎖-執行緒安全

uniqueInstance 只需要被例項化一次，之後就可以直接使用了。加鎖操作只需要對例項化那部分的程式碼進行，只有當 uniqueInstance 沒有被例項化時，才需要進行加鎖。

雙重校驗鎖先判斷 uniqueInstance 是否已經被例項化，如果沒有被例項化，那麼才對例項化語句進行加鎖。

public class ChocolateBoiler {
	private boolean empty;
	private boolean boiled;
	private static volatile ChocolateBoiler uniqueInstance;
  
	private ChocolateBoiler() {
		empty = true;
		boiled = false;
	}
  
	public static ChocolateBoiler getInstance() {
		if (uniqueInstance == null) {
			synchronized (ChocolateBoiler.class){
				if(uniqueInstance==null){
					System.out.println("Creating unique instance of Chocolate Boiler");
					uniqueInstance = new ChocolateBoiler();
				}
			}
		}
		System.out.println("Returning instance of Chocolate Boiler");
		return uniqueInstance;
	}

	public void fill() {
		if (isEmpty()) {
			empty = false;
			boiled = false;
			// fill the boiler with a milk/chocolate mixture
		}
	}
 
	public void drain() {
		if (!isEmpty() && isBoiled()) {
			// drain the boiled milk and chocolate
			empty = true;
		}
	}
 
	public void boil() {
		if (!isEmpty() && !isBoiled()) {
			// bring the contents to a boil
			boiled = true;
		}
	}
  
	public boolean isEmpty() {
		return empty;
	}
 
	public boolean isBoiled() {
		return boiled;
	}
}

考慮下面的實現，也就是隻使用了一個 if 語句。在 uniqueInstance == null 的情況下，如果兩個執行緒都執行了 if 語句，那麼兩個執行緒都會進入 if 語句塊內。雖然在 if 語句塊內有加鎖操作，但是兩個執行緒都會執行 uniqueInstance = new Singleton(); 這條語句，只是先後的問題，那麼就會進行兩次例項化。因此必須使用雙重校驗鎖，也就是需要使用兩個 if 語句。

if (uniqueInstance == null) {
    synchronized (Singleton.class) {
        uniqueInstance = new ChocolateBoiler();
    }
}

uniqueInstance 採用 volatile 關鍵字修飾也是很有必要的， uniqueInstance = new Singleton(); 這段程式碼其實是分為三步執行：

  1. 為 uniqueInstance 分配記憶體空間
  2. 初始化 uniqueInstance
  3. 將 uniqueInstance 指向分配的記憶體地址

但是由於 JVM 具有指令重排的特性，執行順序有可能變成 1>3>2。指令重排在單執行緒環境下不會出現問題，但是在多執行緒環境下會導致一個執行緒獲得還沒有初始化的例項。例如，執行緒 T1 執行了 1 和 3，此時 T2 呼叫 getUniqueInstance() 後發現 uniqueInstance 不為空，因此返回 uniqueInstance，但此時 uniqueInstance 還未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保證在多執行緒環境下也能正常執行。

4.5 靜態內部類實現

當 Singleton 類載入時，靜態內部類 SingletonHolder 沒有被載入進記憶體。只有當呼叫 getUniqueInstance() 方法從而觸發 SingletonHolder.INSTANCE 時 SingletonHolder 才會被載入，此時初始化 INSTANCE 例項，並且 JVM 能確保 INSTANCE 只被例項化一次。

這種方式不僅具有延遲初始化的好處，而且由 JVM 提供了對執行緒安全的支援。

public class ChocolateBoiler {
	private boolean empty;
	private boolean boiled;

	private static class ChocolateBoilerHolder{
		private static ChocolateBoiler uniqueInstance=new ChocolateBoiler();
	}

	private ChocolateBoiler() {
		empty = true;
		boiled = false;
	}
  
	public static ChocolateBoiler getInstance() {
		return ChocolateBoilerHolder.uniqueInstance;
	}

	public void fill() {
		if (isEmpty()) {
			empty = false;
			boiled = false;
			// fill the boiler with a milk/chocolate mixture
		}
	}
 
	public void drain() {
		if (!isEmpty() && isBoiled()) {
			// drain the boiled milk and chocolate
			empty = true;
		}
	}
 
	public void boil() {
		if (!isEmpty() && !isBoiled()) {
			// bring the contents to a boil
			boiled = true;
		}
	}
  
	public boolean isEmpty() {
		return empty;
	}
 
	public boolean isBoiled() {
		return boiled;
	}
}

4.6 列舉實現

public enum Singleton {

    INSTANCE;

    private String objName;


    public String getObjName() {
        return objName;
    }


    public void setObjName(String objName) {
        this.objName = objName;
    }


    public static void main(String[] args) {

        // 單例測試
        Singleton firstSingleton = Singleton.INSTANCE;
        firstSingleton.setObjName("firstName");
        System.out.println(firstSingleton.getObjName());
        Singleton secondSingleton = Singleton.INSTANCE;
        secondSingleton.setObjName("secondName");
        System.out.println(firstSingleton.getObjName());
        System.out.println(secondSingleton.getObjName());

        // 反射獲取例項測試
        try {
            Singleton[] enumConstants = Singleton.class.getEnumConstants();
            for (Singleton enumConstant : enumConstants) {
                System.out.println(enumConstant.getObjName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

該實現在多次序列化再進行反序列化之後，不會得到多個例項。而其它實現需要使用 transient 修飾所有欄位，並且實現序列化和反序列化的方法。

該實現可以防止反射攻擊。在其它實現中，通過 setAccessible() 方法可以將私有建構函式的訪問級別設定為 public，然後呼叫建構函式從而例項化物件，如果要防止這種攻擊，需要在建構函式中新增防止多次例項化的程式碼。該實現是由 JVM 保證只會例項化一次，因此不會出現上述的反射攻擊。

5.Examples

  • Logger Classes
  • Configuration Classes
  • Accesing resources in shared mode
  • Factories implemented as Singletons

6. JDK

相關推薦

Java設計模式(五)：單例設計模式

1. 應用場景 一個無狀態的類使用單例模式節省記憶體資源。 比如說執行緒池、快取、對話方塊、設定偏好和登錄檔物件、日誌物件、充當印表機、顯示卡等裝置的驅動程式物件。 2. 概念 確保一個類只有一個例項，並提供該例項的全域性訪問點。 3.Class Diagram 使用一個

Java設計模式1：單例模式

咳咳，想系統的整理一下知識想了好久了，畢竟工作了快半年了，業務程式碼感覺已經寫得差不多了，明顯感覺到又到了再夯實一遍基礎的時候了，畢竟基礎打得好後面才能得心應手，事半功倍。所以就從設計模式這裡開始看吧。   設計模式感覺在寫程式碼的時候也是挺重要的，確實有些時候就是不知道該如何設計

Java設計模式4：單例模式

Java設計模式4：單例模式 單例模式 這種模式涉及到一個單一的類，該類負責建立自己的物件，同時確保只有單個物件被建立。這個類提供了一種訪問其唯一的物件的方式，可以直接訪問，不需要例項化該類的物件。單例模式有以下特點： 1、單例類只能有一個例項 2

JAVA設計模式之單例模式-快速理解Java中的五種單例模式(轉)

百度百科對單例模式的介紹 顯然單例模式的要點有三個；一是某個類只能有一個例項；二是它必須自行建立這個例項；三是它必須自行向整個系統提供這個例項。 從具體實現角度來說，就是以下三點：一是單例模式的類只提供私有的建構函式，二是類定義中含有一個該類的靜態私有物件，三是該

五、單例設計模式

println pre log 內存 urn args 懶漢 logs pan /* 設計模式：解決某一類問題最有效的方式 單例設計模式：解決的是一個類在內存中只有一個對象的問題 1:構造方法私有化 2:構造方法私有化之後，一個對象都不能創建了，所以只能在類中創建對

JAVA基礎（51）---單例設計模式

設計模式 設計模式（Design pattern）是一套被反覆使用、多數人知曉的、經過分類編目的、程式碼設計經驗的總結。使用設計模式是為了可重用程式碼、讓程式碼更容易被他人理解、保證程式碼可靠性。 毫無疑問，設計模式於他人於系統都是多贏的，設計模式使程式碼編制真正工程化，設計模式是軟體工程的

Java基礎個人筆記之單例設計模式與許可權

設計模式：對問題行之有效的解決方式。其實它是一種思想。 1,單例設計模式。 解決的問題：就是可以保證一個類在記憶體中的物件唯一性。 必須對於多個程式使用同一個配置資訊物件時，就需要保證該物件的唯一性。 如何保證物件唯一性呢？ 1，不允許其他程式用new建立該類物件。 2，在該類建

設計模式篇：單例模式

在遊戲開發中，我們常常會在一個或多個類中引用到另一個類的方法。而這種情況下，我們通常是希望引用到的這個類是同一個類，因為我們要保證資料的同步性和一致性。 因此，單例模式就應運而生了。 單例模式，保證一個類僅有一個例項，並提供一個訪問它的全域性訪問點。 單例模式一般寫法 p

經典設計模式(二)：單例模式

版權宣告 最近很多爬蟲來我部落格爬文章，轉載可以，但請保留原文出處及版權宣告，即便是在中國 本文作者：低調小熊貓 本文連結：https://aodeng.cc/archives/dan-li-mo-shi 版權宣告：本文采用知識共享署名 4.0 國際許可協

設計模式2：單例模式

單例模式 確保一個類中只有一個例項，自行例項化並向整個系統提供這個例項，這個類被稱為單例類，它提供全域性的訪問方法 特點 在類中只有一個例項，並提供一個靜態的getInstacne（）方法用於外界唯一訪問這個例項 防止在外部對其例項化，建構函式私有化 在單例類內部定

面試題剖析：單例設計模式執行緒安全問題

本文作者：黃海燕，叩丁狼高階講師。原創文章，轉載請註明出處。 1. volatile 關鍵字 1.1 volatile 關鍵字作用： 在百度百科擷取的描述如下： 叩丁狼教育.png 說明volatile 關鍵字作用作用有兩點： 防止指令重

菜雞的Java筆記 第二十九 單例設計模式

SingleCase 單例設計模式        1.單例設計模式的特點        2.多例設計模式的特點    內容    

設計模式之：單例

設計模式是經過總結、優化的，對我們經常會碰到的一些程式設計問題的可重用解決方案。後續會就常用的設計模式進行整理。 單例 顧名思義就是一個類至多隻能例項化一次，也可以不例項化。 作用 保證一個類只有一個例項，並提供一個它的全域性訪問點。相當於全域性變數，但防止了名稱空間被汙染。

C#基礎：單例設計模式

單例模式就是保證在整個應用程式的生命週期中，在任何時刻，被指定的類只有一個例項，併為客戶程式提供一個獲取該例項的全域性訪問點     public class SingleTon     {         public string name;         

Java多執行緒-48-單例設計模式

前面學習了多執行緒的一些知識，這篇來學習並掌握什麼是單例設計模式，以及常見的單例模式寫法有哪些。先來理解什麼是單例模式，單例就是保證類在記憶體中只有一個物件。我們知道，類是可以通過多種方式去獲取物件，例如常見的new物件。在記憶體中只有一個物件，如果這句話不好理解。這裡，很多人都用過seleni

設計模式（二）——（建立型模式）：單例模式

    本次部落格說的是設計模式的第一類：        建立型模式 (分別有  ：單例模式；簡單工廠模式；工廠模式；抽象工廠模式；建造者模式；原型模式)，下面一一介紹；一   . 單例模式：    1.  概述：        2. 懶漢式：（1）參考程式：        

設計模式：單例設計模式

內部 建議 null 需要 餓漢 重排序 let sin 網站 單例設計模式 由於某些類創建對象可能會耗費內存和花費時間。一般將這種類設計為單例設計模式會比較好。 1.對象在內存中只有一個，減少了內存的開銷 2.可以控制對象的創建時刻 單例模式的特點： 1.單例的類在整個J

設計模式一：單例模式

單例模式是最簡單的一個，也是比較常用的一個。所以，首先就拿它先開刷了，哈哈。  說起單例模式，有的人覺得沒啥呀，不就是一個類只產生一個物件麼？ 是的，沒錯，但是不知道你有沒有避過這些坑呢？？？ 讓

快速理解Java中的五種單例模式

嵌套類 ati class 由於 aop 適合 singleton 重復 code 解法一：只適合單線程環境（不好） package test; /** * @author xiaoping * */ public class Singleton { pri

【設計模式系列-創造型模式篇】-單例設計模式

單例模式定義 單例模式是一個比較簡單的模式，其定義如下：Ensure a class has only one instance,and provide a global point of access to it.確保某一個類只有一個例項，而且自行例項化並向整個系統提供這個例項。 單例模式應用場景 1