2. 程式人生 > >設計模式：單例模式-懶漢模型和餓漢模型

設計模式：單例模式-懶漢模型和餓漢模型

阿新 • • 發佈：2019-02-15

什麼是單例模式？

保證一個類只有一個例項，並提供一個訪問它的全域性訪問點。首先，需要保證一個類只有一個例項；在類中，要構造一個例項，就必須呼叫類的建構函式，如此，為了防止在外部呼叫類的建構函式而構造例項，需要將建構函式的訪問許可權標記為protected或private；最後，需要提供要給全域性訪問點，就需要在類中定義一個static函式，返回在類內部唯一構造的例項。

要求：

（1）單例類保證全域性只有一個自行建立的例項物件
（2）單例類提供獲取這個唯一例項的介面

分類：

（1）懶漢模式：只有當呼叫物件時才建立例項，相對而言，實現程式碼較複雜但實用性強。
（2）餓漢模式：在執行main函式開始就呼叫建立物件。這種實現方式簡單高效，但適用性受到限制。在main函式之前建立執行緒可能會出現問題，在動態庫里程序可能崩潰。

懶漢模式

#include<iostream>
#include<mutex>
#include<Windows.h>
using namespace std;

class Singleton
{
public:
    static Singleton* GetInstance()//獲取唯一例項的介面函式
    {
        if (_inst == NULL)//建立例項
        {
            _inst = new Singleton;
        }
        return _inst;
    }

    void
 
 Print()
    {
        cout << "Singleton: " << this << endl;
    }

private:
    int _a;
    Singleton()//將建構函式設為私有，防止在類外建立例項
        :_a(0)
    {}
    static Singleton* _inst;//將指向例項的指標定義為靜態私有，這樣定義靜態成員函式獲取物件例項 
};

Singleton* Singleton::_inst = NULL;//類外初始化靜態成員

void Test1()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
}
int
 
 main()
{
    Test1();
    system("pause");
    return 0;
}

這裡寫圖片描述

看上述結果，的確是只產生了一個例項物件，但如果在類外拷貝或是賦值呢？這又如何保證只產生一個例項呢？所以，我們還應該做到防拷貝。，即將拷貝構造和賦值運算子的過載宣告為私有（類似於string 類防拷貝的實現）。

class Singleton
{
public:
    static Singleton* GetInstance()//獲取唯一例項的介面函式
    {
        if (_inst == NULL)//建立例項
        {
            _inst = new Singleton;
        }
        return _inst;
    }

    void Print()
    {
        cout << "Singleton: " << this << endl;
    }

private:
    int _a;
    Singleton()//將建構函式設為私有，防止在類外建立例項
        :_a(0)
    {}

    Singleton(const Singleton&);
    Singleton& operator = (const Singleton&);
    static Singleton* _inst;//將指向例項的指標定義為靜態私有，這樣定義靜態成員函式獲取物件例項 
};

Singleton* Singleton::_inst = NULL;//類外初始化靜態成員

上述過程我們看似已經實現了單例模式只能建立一個例項且只有一個唯一的介面函式，但是，這只是在單執行緒環境下，而如果有多執行緒同時訪問的時候就會出現執行緒安全問題。在linux環境下，我們使用pthread_mutex加鎖保證執行緒安全，這裡我們同樣採用加鎖機制。

class Singleton
{
public:
    static Singleton* GetInstance()//獲取唯一例項的介面函式
    {
        _mtx.lock();//加鎖，加鎖期間其他執行緒不能訪問臨界區
        if (_inst == NULL)//建立例項
        {
            _inst = new Singleton;
        }
        _mtx.unlock();//解鎖
        return _inst;
    }

    void Print()
    {
        cout << "Singleton: " << this << endl;
    }

private:
    int _a;
    Singleton()//將建構函式設為私有，防止在類外建立例項
        :_a(0)
    {}

    Singleton(const Singleton&);
    Singleton& operator = (const Singleton&);
    static Singleton* _inst;//將指向例項的指標定義為靜態私有，這樣定義靜態成員函式獲取物件例項 
    static mutex _mtx; // 保證執行緒安全的互斥鎖
};

mutex Singleton::_mtx;//_mtx會呼叫mutex預設的無參建構函式，所以不用初始化
Singleton* Singleton::_inst = NULL;//類外初始化靜態成員

而上述方案又存在一個問題，當我們加鎖後申請資源時程式崩潰或是異常終止，而我們還沒來得及釋放鎖資源，這時就會導致異常退出的執行緒一直擁有鎖資源，而其他執行緒無法訪問臨界資源。這樣既造成了死鎖問題。

如何解決死鎖問題呢？在學習只能智慧指標時，我們瞭解過RAII機制（資源分配初始化）， RAII利用建構函式分配並初始化資源，利用解構函式釋放資源，保證原子性訪問。所以這裡我們使用RAII 機制自己“造輪子”。

class Lock
{
public:
    Lock(mutex& mtx)
        :_mtx(mtx)
    {
        _mtx.lock();
    }

    ~Lock()
    {
        _mtx.unlock();
    }
protected:
    Lock(const Lock&);
    Lock& operator = (const Lock&);
private:
    mutex& _mtx;
};


class Singleton
{
public:
    static Singleton* GetInstance()//獲取唯一例項的介面函式
    {
        Lock lock(_mtx);//RAII機制
        if (_inst == NULL)//建立例項
        {
            _inst = new Singleton;
        }
        return _inst;
    }

    void Print()
    {
        cout << "Singleton: " << this << endl;
    }

private:
    int _a;
    Singleton()//將建構函式設為私有，防止在類外建立例項
        :_a(0)
    {}

    static mutex _mtx; // 保證執行緒安全的互斥鎖
    Singleton(const Singleton&);
    Singleton& operator = (const Singleton&);
    static Singleton* _inst;//將指向例項的指標定義為靜態私有，這樣定義靜態成員函式獲取物件例項 
};

Singleton* Singleton::_inst = NULL;//類外初始化靜態成員
mutex Singleton::_mtx;//_mtx會呼叫mutex預設的無參建構函式，所以不用初始化

而實際上，庫中是有這樣的加鎖機制的，我們可以直接呼叫庫函式進行加鎖。

 lock_guard<mutex>lock(_mtx);

我們的單例模式要求是執行緒安全且高效，現在我們已經實現了執行緒安全，那麼高效如何實現？需要使用雙檢查。，而在上述過程中，我們建立例項時，使用

_inst = new Singleton

這行程式碼，系統執行時，會呼叫operator new 、建構函式及賦值運算子，但在不同的編譯器下，可能會對它進行不同程度的優化，這樣我們就無法保證內部的呼叫順序，因此我們對此優化，並加入記憶體柵欄。
那麼既然我們使用了new開闢空間，自然是要delete釋放空間的。在實際專案中，我們其實並不關心單例模式的釋放，因為全域性就一個例項，它一直伴隨著這個軟體的使用，可以說它的生命週期隨軟體。當這個軟體停止了，那這個例項自然也就沒有了。但有些情況是必須我們手動來釋放資源的：
（1）在類中，有一些檔案鎖，檔案控制代碼，資料庫連線等等，這些隨著程式的關閉而不會立即關閉的資源，必須要在程式關閉前，進行手動釋放。
（2）有強迫症的程式設計師（我覺得程式設計師一般都有強迫症的哈哈）

基於以上的分析和不斷優化的過程，我們給出完整版的懶漢模式的實現：

class Singleton
{
public:
    static Singleton* GetInstance()//獲取唯一例項的介面函式
    {
        if (_inst == NULL)//雙檢查機制，只有建立例項的時候才進行加鎖解鎖來提高程式碼效率
        {
            //Lock lock(_mtx);//RAII機制
            lock_guard<mutex>lock(_mtx);
            if (_inst == NULL)//建立例項
            {
                Singleton* tmp = new Singleton;
                MemoryBarrier();//記憶體柵欄
                _inst = tmp;
            }
        }
        return _inst;//返回例項化的唯一物件
    }

    void Print()
    {
        cout << "Singleton: " << _inst << endl;
    }

    static void DellInstance()//在某些情況才需要釋放
    {
        lock_guard<mutex> lock(_mtx);//防止物件被釋放多次

        if (_inst)
        {
            cout << "delete" << endl;
            delete _inst;
            _inst = NULL;//防止野指標的出現
        }
    }

    struct GC
    {
        ~GC()
        {
            DellInstance();
        }
    };
private:
    int _a;
    Singleton()//將建構函式設為私有，防止在類外建立例項
        :_a(0)
    {}

    ~Singleton()
    {

    }
    static mutex _mtx; // 保證執行緒安全的互斥鎖
    Singleton(const Singleton&);
    Singleton& operator = (const Singleton&);
    static Singleton* _inst;//將指向例項的指標定義為靜態私有，這樣定義靜態成員函式獲取物件例項 
};

Singleton* Singleton::_inst = NULL;//類外初始化靜態成員
mutex Singleton::_mtx;//_mtx會呼叫mutex預設的無參建構函式，所以不用初始化
static Singleton::GC gc;

void Test1()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();

    Singleton::DellInstance();
    //atexit(Singleton::DellInstance);//也註冊回撥函式，在main函式之後呼叫析構
}
int main()
{
    Test1();
    system("pause");
    return 0;
}

這裡寫圖片描述

餓漢模式
—-餓漢模式1

class Singleton
{
public:
    static Singleton& GetInstance()
    {
        static Singleton inst;//靜態變數只會建立一次
        return inst;
    }
    void Print()
    {
        cout << "Singleton:" << this << endl;
    }
protected:
    Singleton()
        :_a(0)
    {}
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);

    int _a;
};


void Test1()
{
    Singleton::GetInstance().Print();
    Singleton::GetInstance().Print();
    Singleton::GetInstance().Print();
}

int main()
{
    Test1();
    system("pause");
    return 0;
}

餓漢模式2

#include<assert.h>
class Singleton
{
public:
    static Singleton& GetInstance()
    {
        assert(_inst);
        return *_inst;
    }
    void Print()
    {
        cout << "Singleton:" << _a << endl;
    }
protected:
    Singleton()
        :_a(0)
    {}
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);

    static Singleton* _inst;
    int _a;
};

Singleton* Singleton::_inst = new Singleton;//靜態成員在main函式之前初始化

void Test()
{
    Singleton::GetInstance().Print();
    Singleton::GetInstance().Print();
    Singleton::GetInstance().Print();
}

int main()
{
    Test();
    system("pause");
    return 0;
}

總結：懶漢式的特點是用到例項化的時候才會載入，而餓漢式是一開始就載入了。兩種方案的建構函式和公用方法都是靜態的（static），例項和公用方法又都是私有的（private）。但是餓漢式每次呼叫的時候不用做建立，直接返回已經建立好的例項。這樣雖然節省了時間，但是卻佔用了空間，例項本身為static的，會一直在記憶體中帶著。懶漢式則是判斷，在用的時候才載入，會影響程式的速度。

推薦部落格：單例模式 博主舉的例子有助於大家理解單例模式。

相關推薦

設計模式：單例模式-懶漢模型和餓漢模型

什麼是單例模式？ 保證一個類只有一個例項，並提供一個訪問它的全域性訪問點。首先，需要保證一個類只有一個例項；在類中，要構造一個例項，就必須呼叫類的建構函式，如此，為了防止在外部呼叫類的建構函式而構造例項，需要將建構函式的訪問許可權標記為protected或pr

設計模式：單例模式（懶漢）

/** * 單例模式。 * @author Bright Lee */ public class LazySingleton { private static volatile LazySingleton instance; private LazySingleton() {

設計模式：單例模式的三種創建方式及其各自的優缺點

singleton dmi 創建 檢查 public pos return style tin 單例模式： 確保一個類僅僅有一個實例，並提供全局訪問點。在Java中實現單例模式須要私有的構造器，一個靜態方法和一個靜態變量。確定在性能和資源上 的限制，怎樣選擇適當的方案來

C#設計模式：單例模式

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

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

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

PHP設計模式：單例模式

php singleton 單例模式 應用場景：在一次http請求中，多個地方使用到了數據庫連接，使用單例可以只需要創建一個連接。一個龐大的類被多次實例化的時候，會浪費巨大的內存空間。使用單例模式可以使多個對象共享內存中存在類的靜態空間。代碼示例：<?php //final防止類被

java設計模式：單例模式

速度 [] urn == public void 支持 不變 實例化 所謂設計模式，就是一套反復會他人使用，大多數人熟知的一種設計模式。 優點： 讓代碼更容易被他人理解，保證的代碼的重用性和可靠性。 單例模式分為兩種，一種是餓漢模式，另外一種是懶漢模式。 單例模式適

Java設計模式（三）之建立型模式：單例模式

一、概念： java中單例模式是一種常見的設計模式，單例模式的寫法有好幾種，這裡主要介紹三種：懶漢式單例、餓漢式單例、登記式單例。 單例模式有以下特點： （1）單例類只能有一個例項； （2）單例類必須自己建立自己的唯一例項； （3）單例類必須給所有其他物件提供這一例項。 單例

Spring中常用的設計模式：單例模式

在Spring中，Bean可以被定義為兩種模式：prototype（原型）和singleton（單例）。 singleton（單例） 只有一個共享的例項存在，所有對這個Bean的請求都會返回這個唯一的例項。 prototype（原型） 對這個Bean的每次請求都會建立一個新

設計模式：單例模式（餓漢）

/** * 單例模式。 * @author Bright Lee */ public class HungrySingleton { private static final HungrySingleton instance = new HungrySingleton();

設計模式：單例模式|菜鳥教程

定義 單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。 這種模式涉及到一個單一的類，該類負責建立自己的物件，同時確保只有單個物件被建立。這個類提供了一種

設計模式：單例模式程式程式碼範例

/// <summary> /// 單例模式 /// </summary> public sealed class Singleton { private static Si

設計模式：單例模式的三種建立方式及其各自的優缺點

單例模式：確保一個類只有一個例項，並提供全域性訪問點。在Java中實現單例模式需要私有的構造器，一個靜態方法和一個靜態變數。確定在效能和資源上的限制，如何選擇適當的方案來實現單例，以解決多執行緒的問題

一天一個設計模式：單例模式

概念： 　　作為物件的建立模式，單例模式確保某一個類只有一個例項，而且自行例項化，並向整個系統提供這個例項。 特點： 　　1.單例類只能有一個例項 　　2.單例類必須建立自己的唯一例項 　　3.單例類必須給其他所有物件提供這一例項。 餓漢式單例類 public class EagerSingleton {

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

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

JDK與設計模式：單例模式

      單例模式用於建立那些在軟體系統中獨一無二的物件，例如資料庫管理物件，你希望在應用程式中共享該物件，完成對資料庫的統一管理以及某些軟體的引擎（如圖片渲染引擎），不同模組需要共享引擎提供的功能，而又不想建立多個引擎物件，因為引擎是一種耗資源的物件。 1、單例模式

設計模式：單例模式（Singleton）

  單例模式在23個設計模式中算得上是最簡單的一個了，也許你會有異議，那就換成“最簡單之一”，這樣就嚴謹了很多。   單例模式：保證一個類僅有一個例項，並提供一個訪問它的全域性訪問點。   適用性：當類只能有一個例項而且客戶可以從一個眾所周知的訪問點訪問它時

設計模式：單例模式-餓漢式 懶漢式

test 一加 單例 設計模式 餓漢式 private 調用 ati 創建 懶漢模式 class Test{ //懶漢模式 類加載後不創建對象，當調用getTest時才創建對象 //延遲加載 static Test s= null; private Test(){}

設計模式：單例模式 (關於餓漢式和懶漢式)

定義 單例模式是比較常見的一種設計模式，目的是保證一個類只能有一個例項，而且自行例項化並向整個系統提供這個例項，避免頻繁建立物件，節約記憶體。 單例模式的應用場景很多， 比如我們電腦的作業系統的回收站就是一個很好的單例模式應用，電腦上的檔案、視訊、音樂等被刪除後都會進入到回收站中；還有計算機中的印表機也是採用

設計模式：單例模式介紹及8種寫法（餓漢式、懶漢式、Double-Check、靜態內部類、列舉）

# 一、餓漢式（靜態常量） 這種餓漢式的單例模式構造的步驟如下： 1. 構造器私有化；（防止用new來得到物件例項） 2. 類的內部建立物件；（因為1，所以2） 3. 向外暴露一個靜態的公共方法；（getInstance） 示例： ```java class Singleton{ //