2. 程式人生 > >01：單例模式——C++實現

01：單例模式——C++實現

阿新 • • 發佈：2018-12-01

目錄

一、介紹

二、應用場景

三、要點

四、樣例Demo

4.1、區域性靜態變數

4.2、懶漢式與餓漢式

懶漢式

餓漢式 

4.3、執行緒安全 

4.4、資源釋放 

五、優缺點

優點

缺點：

一、介紹

       單例模式（Singleton Pattern）：這種模式涉及到一個單一的類，該類負責建立自己的物件，同時確保只有單個物件被建立。這個類提供了一種訪問其唯一的物件的方式，可以直接訪問，不需要例項化該類的物件。

 

二、應用場景

      1、Windows 是多程序多執行緒的，在操作一個檔案的時候，就不可避免地出現多個程序或執行緒同時操作一個檔案的現象，所以所有檔案的處理必須通過唯一的例項來進行。

      2、一個系統中可以存在多個列印任務，但是隻能有一個正在工作的任務；一個系統只能有一個視窗管理器或檔案系統；一個系統只能有一個計時工具或ID(序號)生成器。如在Windows中就只能開啟一個工作管理員。

一些裝置管理器常常設計為單例模式。

 

三、要點

單例模式要點有如下三點：

  1. 單例類只能有一個例項。
  2. 單例類必須自己建立自己的唯一例項。
  3. 單例類必須給所有其他物件提供這一例項。

從實現角度即以下三點：

  1. 單例模式的類只提供私有的建構函式。
  2. 類定義中含有一個該類的靜態私有物件。
  3. 該類提供了一個靜態的公有的函式用於建立或獲取它本身的靜態私有物件。

同時還要注意：1、執行緒安全（雙檢鎖DCL：double-checked-lock）。2、資源釋放。

 

四、樣例Demo

4.1、區域性靜態變數

    這種方式很常見，實現簡單，且無需擔心單例的銷燬問題。

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

// 非真正意義上的單例
class Singleton
{
public:
	static Singleton& GetInstance()
	{
		static Singleton instance;
		return instance;
	}

private:
	Singleton() {}
};

但這並非真正意義上的單例，當使用如下方式訪問單例時：

Singleton single = Singleton::GetInstance();

因為編譯器會生成一個預設的拷貝建構函式，這時會出現一個類拷貝問題，違背了單例特性。要避免該問題，可以有如下兩種方法：

1、將GetInstance函式的返回型別修改為指標，而非引用。

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

// 單例
class Singleton
{
public:
	// 修改返回型別為指標型別
	static Singleton* GetInstance()
	{
		static Singleton instance;
		return &instance;
	}

private:
	Singleton() {}
};

#endif // SINGLETON_H

 2、顯示的宣告類的拷貝建構函式並重載賦值運算子。

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>
using namespace std;

// 單例
class Singleton
{
public:
	static Singleton& GetInstance()
	{
		static Singleton instance;
		return instance;
	}

	void doSomething() {
		cout << "Do something" << endl;
	}

private:
	Singleton() {}  // 建構函式（被保護）
	Singleton(Singleton const &);  // 無需實現
	Singleton& operator = (const Singleton &);  // 無需實現
};

#endif // SINGLETON_H

這樣就可以保證只有一個例項，又不用擔心記憶體回收問題。

Singleton::GetInstance().doSomething();  // OK
Singleton single = Singleton::GetInstance();  // Error 不能編譯通過

 

4.2、懶漢式與餓漢式

    先看Singleton的標頭檔案，懶漢與餓漢式公用部分：

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

// 單例 - 懶漢式/餓漢式公用
class Singleton
{
public:
	static Singleton* GetInstance();

private:
	Singleton() {}  // 建構函式（被保護）

private:
	static Singleton *m_pSingleton;  // 指向單例物件的指標
};

#endif // SINGLETON_H

懶漢式

特點：Lazy初始化；非多執行緒安全。

優點：第一次呼叫才初始化，避免記憶體浪費。

缺點：必須加鎖才能保證單例，但加鎖會影響效率。

// singleton.cpp
#include "singleton.h"

// 單例 - 懶漢式
Singleton *Singleton::m_pSingleton = NULL;

Singleton *Singleton::GetInstance()
{
	if (m_pSingleton == NULL)
		m_pSingleton = new Singleton();

	return m_pSingleton;
}

餓漢式 

特點：非Lazy初始化；多執行緒安全。

優點：沒有加鎖，執行效率提高。

缺點：類載入時就初始化，浪費記憶體。

// singleton.cpp
#include "singleton.h"

// 單例 - 餓漢式
Singleton *Singleton::m_pSingleton = new Singleton();

Singleton *Singleton::GetInstance()
{
	return m_pSingleton;
}

 

4.3、執行緒安全 

    在懶漢式下有非多執行緒安全問題，引入DCL機制可以解決。

    singleton.h內容:

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>
#include <mutex>
using namespace std;

// 單例 - 懶漢式/餓漢式公用
class Singleton
{
public:
	static Singleton* GetInstance();

private:
	Singleton() {}  // 建構函式（被保護）

private:
	static Singleton *m_pSingleton;  // 指向單例物件的指標
	static mutex m_mutex;  // 鎖
};

#endif // SINGLETON_H

     singleton.cpp內容:

// singleton.cpp
#include "singleton.h"

// 單例 - 懶漢式（雙檢鎖 DCL 機制）
Singleton *Singleton::m_pSingleton = NULL;
mutex Singleton::m_mutex;

Singleton *Singleton::GetInstance()
{
	if (m_pSingleton == NULL) {
		std::lock_guard<std::mutex> lock(m_mutex);  // 自解鎖
		if (m_pSingleton == NULL) {
			m_pSingleton = new Singleton();
		}
	}
	return m_pSingleton;
}

這樣可以保證執行緒安全，只是會帶來一點效能影響。

 

4.4、資源釋放 

有記憶體申請，就有記憶體釋放，可以採用如下方式：

1、主動釋放（手動呼叫介面釋放記憶體）。

2、自動釋放（程式自己釋放）。

 

要手動釋放資源，新增一個static介面，編寫需要釋放資源的程式碼。

// 單例 - 主動釋放
static void DestoryInstance()
{
	if (m_pSingleton != NULL) {
		delete m_pSingleton;
		m_pSingleton = NULL;
	}
}

// 需要釋放資源的時候再手動呼叫
Singleton::GetInstance()->DestoryInstance();

方式雖然簡單，但很多時候，容易忘記呼叫DestoryInstance，這時可以採用更簡便方法。

// singleton.h
#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>
using namespace std;

// 單例 - 自動釋放
class Singleton
{
public:
	static Singleton* GetInstance();

private:
	Singleton() {}  // 建構函式（被保護）

private:
	static Singleton *m_pSingleton;  // 指向單例物件的指標

	// GC 機制
	class GC
	{
	public:
		~GC()
		{
			// 可以在這裡銷燬所有的資源，例如：db 連線、檔案控制代碼等
			if (m_pSingleton != NULL) {
				cout << "Here destroy the m_pSingleton..." << endl;
				delete m_pSingleton;
				m_pSingleton = NULL;
			}
		}
		static GC gc;  // 用於釋放單例
	};
};

#endif // SINGLETON_H

 只需要宣告Sinleton::GC即可：

// main.cpp
#include "singleton.h"

Singleton::GC Singleton::GC::gc; // 重要

int main()
{
	Singleton *pSingleton1 = Singleton::GetInstance();
	Singleton *pSingleton2 = Singleton::GetInstance();

	cout << (pSingleton1 == pSingleton2) << endl;

	return 0;
}

程式執行結束時，系統會呼叫Singleton的靜態成員GC的解構函式，該解構函式會進行資源的釋放。這種方式最大優點就是在“不知不覺”中進行，所以對開發者來說尤為省心。

 

五、優缺點

優點

      1、例項控制：單例模式會阻止其他物件例項化自己的單例物件的副本，從而確保所有物件都訪問唯一例項，避免對資源的多重利用。

      2、靈活性：因為類控制了例項化過程，所以類可以靈活更改例項化過程。

 

缺點：

      1、開銷：雖然數量少，但如果每次物件請求都要檢查是否存在類例項，將仍然需要一些開銷。可以通過使用靜態初始化解決（有的也將開銷少劃為優點，應該是當正確使用時為優點。）。

      2、可能的開發混淆：使用單例物件時，開發人員必須記住不能使用new關鍵字例項化此物件。因為可能無法訪問庫原始碼，開發人員可能會意外發現無法直接例項化此類。

      3、物件生存期：不能解決刪除單個物件的問題。在提供記憶體管理的語言中（例如基於.NET Framework的語言），只有單例類能夠導致例項被取消分配，因為它包含對該例項的私有引用。在某些語言中（如 C++），其他類可以刪除物件例項，但這樣會導致單例類中出現懸浮引用。

 

 

相關推薦

01：單例模式——C++實現

目錄 一、介紹 二、應用場景 三、要點 四、樣例Demo 4.1、區域性靜態變數 4.2、懶漢式與餓漢式 懶漢式 餓漢式  4.3、執行緒安全  4.4、資源釋放  五、優缺點 優點 缺點： 一、介紹

劍指offer：面試題二：單例模式的實現（使用C++語言）

#include <iostream> #include <iomanip> #include <cstdio> #include <cstdlib>

設計模式-單例模式-C++實現

單例模式：保證一個類提供且僅提供一例項，並提供一個訪問它的全域性訪問點。 場景： 1.當類只能有一個例項並且客戶可以從一個公共的介面訪問到例項； 2.當這個唯一的例項應該是通過子類化可擴充套件的，並且客戶應該無需更改程式碼就能使用一個擴充套件的例項。 #include <s

設計模式（一）：單例模式 java實現

參考：http://blog.csdn.net/jason0539/article/details/23297037/ 單例模式：指的是一個類只有一個例項物件。它的設計是為了實現類的單一功能。專注於自己的事情。 有如下三個特點： 單例類只有一個

單例模式(C++實現)

1. 單例模式 （C++實現） 單例模式：保證一個類只有一個物件例項，並提供一個訪問該物件例項的全域性訪問點。 單例模式有兩種實現方法:懶漢模式和餓漢模式。 1.1 懶漢模式 懶漢模式：故名思義，不到萬不得已就不會去例項化類，也就是說在第一次用到類例項時候才會

單例模式——C++實現執行緒安全的單例

一、懶漢模式：即第一次呼叫該類例項的時候才產生一個新的該類例項，並在以後僅返回此例項。 需要用鎖，來保證其執行緒安全性：原因：多個執行緒可能進入判斷是否已經存在例項的if語句，從而non thread safety. 使用double-check來保證thread s

單例模式c++實現方法總結

一  單例模式介紹 單例模式約束了類的例項化，只允許類建立一個物件。 在用程式碼實現單例模式之前，先看看單例模式的類結構：   特點： 1.  類的建構函式外界不可訪問. 2.  提供了建立物件的介面.  二  單例模式C++實現 1.   實現方法一（只作為樣例，不推薦

設計模式——單例模式C++實現

引出問題： 設計一個類，我們只能生成該類的一個物件例項。 不好的解法：只適用於單執行緒環境 因為該類只能生成一個物件例項，那麼該類的建構函式必須是私有的，從而避免他人建立例項。在需要的時候建立該類的一個物件。 下面是程式實現： /****************

Head First 設計模式（C++實現）：單例模式：Singleton

單例模式：確保一個類只有一個例項，並提供一個全域性訪問點 1 .經典單例模式實現 　　我們都很清楚一個簡單的單例模式該怎樣去實現：建構函式宣告為private或protect防止被外部函式例項化，內部儲存一個private static的類指標儲存唯一的例項，例項的動

C#設計模式：單例模式

由於 style 屬性 public readonly 靜態 don 但是 應該 在c#中的單例模式是指在一個AppDomain中只會存在一個經過實例化的對象。單例模式的作用的避免創建更多本來不用創建的對象，因為有一些對象在使用上沒有必要創建那麽多，一個就夠了。單例模式實現

C#設計模式之創建類模式：單例模式

class style 全局 線程同步 性能 就是 線程安全 應用 過程 在程序的設計過程中很多時候系統會要求對於某個類型在一個應用程序域中只出現一次，或者是因為性能的考慮，或者是由於邏輯的要求，總之是有這樣的需求的存在，那在設計模式中正好有這麽一種模式可以來滿足這樣的要求

C#面試分享：單例模式

anim args ret 面試分享 type flags key nim ins C#面試分享：單例模式 提問1：請給出單例模式的實現： 答： public class Animal { private static Animal _instance = null

設計模式之“單例模式”C++/python實現

       單例模式用來只允許建立一個例項的類，比如一個系統中只能有一個工作管理員，對於單伺服器多客戶端系統，伺服器也應該設為單例的。        對於C++單例模式需要滿足以下三點：        1）單例模式的類只提供私有的建構函式；        2）是類定義

C# 單例模式的實現

單例模式讓一個類僅有一個例項，並提供訪問它的全域性訪問點。單例模式的實現通常如下： public class Singleton { private static Singleton singleton; private Singleton()

C++單體類 || 單例模式 的實現

單件模式是設計模式中最簡單的模式了。     定義： 確保一個類只有一個例項，並提供一個全域性的訪問點。 把一個類設計成自己管理的一個單獨例項，同時避免其他類再自行生成例項(所以建構函式用protect或privite) 也提供全域性的訪問點。public函式 一、

設計模式 之 單例模式 (C++ 懶漢經典實現 & DCL實現 & 餓漢經典實現)

顧名思義： 單例模式，指的是僅有一個(類)例項。 即： 在應用程式的整個生命週期中，任何時刻，某個類(單例類)僅存在唯一一個例項。 同時僅提供一個全域性訪問點。 單例的實現一般要求滿足： (1) 類建構函式私有 (2) 提供一個全域性訪問點 一般是靜態的共有方法 一、單

C# 單執行緒和多執行緒下的單例模式的實現

該單例模式是執行緒不安全的，只能在單執行緒下執行，在多執行緒中如果被兩個執行緒同時呼叫Instance屬性時，此時兩個執行緒判斷 if (_instance==null)時都會返回true，就會建立兩個例項。public class Singleton{ /// <

C++ 兩種設計模式：單例模式和觀察者監聽者模式

一、C++中有23種設計模式，大致分為建立型模式，結構型模式以及行為模式， 在這裡自己實現一下單例模式以及觀察者和監聽者模式 二、單例模式 我們通過維護一個static的成員變數來記錄唯一的物件例項，通過提供一個static的介面instance來獲得唯一的例項，就是一

Objective-C 中singleton(單例模式)的實現

OC中的單例很有意思，因為沒辦法像JAVA或C++中把建構函式設為private的來防止其它人直接 new 一個新物件，所以像如下單例的實現方式，只能祈禱大家必須按你要求的方式建立物件，有人不小心直接 [[ xx alloc] init] 建立一個物件，是很難發現的。 s

Muduo庫原始碼分析（8）：單例模式實現

單例模式 保證一個類只有一個例項，並提供一個訪問它的全域性訪問點 Muduo庫實現單例模式的思想： 通過pthread_once在多個執行緒中只會初始化一次的特性實現的執行緒安全的單例模式