2. 程式人生 > >執行緒安全的單例模式也可以很精彩

執行緒安全的單例模式也可以很精彩

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

這篇部落格以多種方式實現單例模式，包括非執行緒安全、執行緒安全的單例模式以及執行緒安全的優化。
餓漢式單例；
懶漢式單例(延遲初始化)；(執行緒不安全)
執行緒安全的單例-synchronized方法
執行緒安全的單例-同步程式碼塊
執行緒安全的單例-顯式鎖ReentrantLock進一步減小鎖的粒度
執行緒安全的單例-DCL(double check lock)

首先可以參考一下我的另外一篇博文了解什麼是單例模式：
單例模式

多執行緒測試獲取單例例項

為了模擬在多執行緒的高併發下同時獲取單例中是例項的情況，我寫了一個測試用例，使用了J.U.C 併發包下的欄珊，使用欄珊的目的是為了讓100個執行緒到達欄珊後互相等待，知道全部到達欄珊然後開放出口，100個執行緒同時發起獲取單例。具體的程式碼如下：

package patterns.singleton_multi;

import java.util.Random;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * Created by louyuting on 17/1/22.
 * 多執行緒測試端-使用欄珊實現100各執行緒同時申請建立單例
 */
 

public class TestClient {

    private static final Integer THREAD_NUM = 100;

    static class NewInstance implements Runnable{
        private String name;

        private CyclicBarrier barrier;//欄珊

        public NewInstance(CyclicBarrier barrier, String name) {
            super();
            this
 
.barrier = barrier;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                //做個延時
                TimeUnit.MILLISECONDS.sleep(1000 * (new Random()).nextInt(8));
                System.out.println(name + " 準備好了...");
                //barrier的await方法，在所有參與者都已經在此 barrier 上呼叫 await 方法之前，將一直等待。
                barrier.await();
            } catch (Exception e) {
                e.printStackTrace();
            }

            System.out.println(name + "的例項的hashcode:"+ Singleton1.getInstance().hashCode());
        }
    }

    /**
     * 測試類的主函式
     * @param args
     */
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(THREAD_NUM, new Runnable() {
            @Override
            public void run() {
                System.out.println("--------------提示:所有執行緒都已經到達.可以執行開始獲取單例了.--------------------");
            }
        });

        ExecutorService executor = Executors.newFixedThreadPool(THREAD_NUM);

        for(int i=0; i<THREAD_NUM; i++){
            if(i<10){
                executor.submit(new NewInstance(barrier, "thread-0"+i));

            }else{
                executor.submit(new NewInstance(barrier, "thread-"+i));
            }
        }
        executor.shutdown();
    }
}

1.餓漢式單例

餓漢式單例是指在方法呼叫前，例項就已經建立好了，所以肯定是執行緒安全的。下面是實現程式碼：

package patterns.singleton_multi;

/**
 * Created by louyuting on 17/1/22.
 * 餓漢式單例模式
 */
public class Singleton1 {
    //單例
    private static Singleton1 instance = new Singleton1();

    //構造器私有,不開放
    private Singleton1(){

    }

    public static Singleton1 getInstance(){
        return instance;
    }
}

使用測試用例的測試結果如下：
這裡寫圖片描述

從執行結果可以看出例項變數額hashCode值一致，這說明物件是同一個，餓漢式單例實現了。

2.懶漢式單例(延遲初始化)；

懶漢式單例是指在方法呼叫獲取例項時才建立例項，因為相對餓漢式顯得“不急迫”，所以被叫做“懶漢模式”。下面是實現程式碼：

package patterns.singleton_multi;

import java.util.concurrent.TimeUnit;

/**
 * Created by louyuting on 17/1/22.
 * 懶漢式單例(延遲初始化)； 多執行緒下完全不安全
 */
public class Singleton2 {
    //單例
    private static Singleton2 instance;

    //構造器私有,不開放
    private Singleton2(){

    }

    public static Singleton2 getInstance(){
        if(instance == null){
            //建立例項前一些耗時操作
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton2();
        }
        return instance;
    }
}

測試用例測試結果如下：
這裡寫圖片描述

從執行結果可以看出例項變數的hashCode值完全一致，這說明物件不是同一個，所以是執行緒不安全的。

3.執行緒安全的單例-synchronized方法

上面的懶漢式單例明顯是執行緒不安全的，要想實現執行緒安全的實現，最簡單的方式就是使用同步原語實現synchronized方法。出現非執行緒安全問題，是由於多個執行緒可以同時進入getInstance()方法，那麼只需要對該方法進行synchronized的鎖同步即可：
原始碼如下：

package patterns.singleton_multi;

import java.util.concurrent.TimeUnit;

/**
 * Created by louyuting on 17/1/22.
 * synchronized 同步方法實現執行緒安全
 */
public class Singleton3 {
    //單例
    private static Singleton3 instance;

    //構造器私有,不開放
    private Singleton3(){

    }

    public synchronized static Singleton3 getInstance(){
        if(instance == null){
            //建立例項前一些耗時操作
            try {
                TimeUnit.MILLISECONDS.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new Singleton3();
        }
        return instance;
    }
}

測試用例的結果是：
這裡寫圖片描述
很顯然實現了執行緒安全。但是這種實現方式的執行效率會很低。同步方法效率低，那我們考慮使用同步程式碼塊來實現：

4.執行緒安全的單例-同步程式碼塊

原始碼如下：

package patterns.singleton_multi;

import java.util.concurrent.TimeUnit;

/**
 * Created by louyuting on 17/1/22.
 * synchronized 同步程式碼塊實現執行緒安全
 */
public class Singleton4 {
    //單例
    private static Singleton4 instance;

    //構造器私有,不開放
    private Singleton4(){

    }

    public static Singleton4 getInstance(){
        //建立例項前一些耗時操作
        try {
            synchronized (Singleton4.class){
                if(instance==null){
                    TimeUnit.MILLISECONDS.sleep(300);
                    instance = new Singleton4();
                }else {
                    //instance非空
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return instance;
    }
}

執行結果如下：
這裡寫圖片描述

同步程式碼塊雖然提交了效率，但是同步程式碼塊把方法內所有的程式碼全部包含在內，效率依然低，還可以優化，接下來我們繼續減小鎖的粒度，使用顯式鎖ReentrantLock進一步減小鎖的粒度

5.執行緒安全的單例-顯式鎖ReentrantLock

我們使用顯式鎖ReentrantLock只鎖住關鍵的程式碼行，原始碼如下：

package patterns.singleton_multi;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by louyuting on 17/1/22.
 * synchronized 同步程式碼塊實現執行緒安全
 */
public class Singleton5 {
    //單例
    private static Singleton5 instance;

    private static Lock lock = new ReentrantLock();

    //構造器私有,不開放
    private Singleton5(){

    }

    public static Singleton5 getInstance(){
        //建立例項前一些耗時操作
        try {
            lock.lock();//加鎖
            if(instance==null){
                TimeUnit.MILLISECONDS.sleep(300);
                instance = new Singleton5();
            }else {
                //instance非空
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
        return instance;
    }
}

測試結果如下：
這裡寫圖片描述
在小粒度下同樣實現了執行緒安全，那麼還能不能優化呢？當然是可以的，我們知道volatile是最輕量級的鎖機制了，那能不能利用volatile來實現呢？接下來就提出了DCL方法。

6.執行緒安全的單例-DCL(double check lock)

為了達到執行緒安全，又能提高程式碼執行效率，我們這裡可以採用DCL的雙檢查鎖機制來完成，DCL的實現將鎖的粒度降低到了最小，僅僅加鎖new例項這一行程式碼，通過最輕量級的volatile實現多執行緒情況下的記憶體可見性。程式碼實現如下：

package patterns.singleton_multi;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by louyuting on 17/1/22.
 * synchronized DCl
 */
public class Singleton6 {
    //使用volatile關鍵字保其可見性
    volatile private static Singleton6 instance;

    private static Lock lock = new ReentrantLock();

    //構造器私有,不開放
    private Singleton6(){

    }

    public static Singleton6 getInstance(){
        //建立例項前一些耗時操作
        try {
            if(instance==null){
                lock.lock();//加鎖
                if(instance == null){//二次檢查  
                    TimeUnit.MILLISECONDS.sleep(300);
                    instance = new Singleton6();
                }
                lock.unlock();
            }else {
                //instance非空
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {

        }
        return instance;
    }
}

檢視測試結果：
這裡寫圖片描述

從執行結果來看，該中方法保證了多執行緒併發下的執行緒安全性。
這裡在宣告變數時使用了volatile關鍵字來保證其執行緒間的可見性；在同步程式碼塊中使用二次檢查，以保證其不被重複例項化。集合其二者，這種實現方式既保證了其高效性，也保證了其執行緒安全性。

自此，優化過程結束了，如果有路過的大佬有更好的優化策略，歡迎私信交流。我今天也是被師兄問到了這個，被吊打才有了這篇博文，歡迎各路大神一起來學習。

本文全部程式碼均可通過github獲得，github地址。

相關推薦

[C++][執行緒安全]單例模式下雙檢查鎖和執行緒

問題 在設計模式中，有一個很經典的模式-單例模式，它可能是實現上最簡單的模式，在程式碼中也經常使用，在單執行緒下，毫無疑問延遲化載入是比較常用的，但是在多執行緒條件下，單例模式的延遲載入可能就會出現一些問題。 如以下的程式碼： T* GetInstance(

C++的單例模式與執行緒安全單例模式（懶漢/餓漢）

單例模式 單例模式：是一種常用的軟體設計模式。在它的核心結構中只包含一個被稱為單例的特殊類。通過單例模式可以保證系統中一個類只有一個例項。即一個類只有一個物件例項。 　　實現簡單的單例模式：建構函式宣告為private或protect防止被外部函式

執行緒安全單例設計模式+序列化

懶漢式單例模式會引來執行緒安全問題，即多執行緒時可能會建立多個例項，而且在反序列化時也可能會建立新的例項。看了大大們的實現方式，覺得以下一種比較簡單方便理解。 一、下面是會造成執行緒安全的餓漢單例模式。用四列印下會發現hashcode不一致 public class Singleton {

java通過雙重檢測或列舉類實現執行緒安全單例(懶漢模式)

雙重檢測實現 /** * 懶漢模式->雙重同步鎖單例模式 */ public class SingletonExample5 { private SingletonExample5() { } //volatile + 雙重檢測機制 -> 禁止指令重排序

執行緒涉及單例模式

/** * 單例模式涉及的兩個問題 * * @author 羅摩銜那 * */ /* * 惡漢式 * 優點:當類被載入的時候,已經建立好了一個靜態的物件,因此,是執行緒安全的 * 缺點:這個物件還沒有被使用就被創建出來了 */ class Single { private s

高效能的執行緒安全單例——Java基礎語法系列

大家都知道，一般實現單例有兩種寫法： 餓漢式 和 懶漢式， 餓漢式是執行緒安全的，在編譯期間已完成初始化，載入到了記憶體裡。 懶漢式一般寫法是非執行緒安全的， 那懶漢式的執行緒安全單例應該如何實現呢，以及如何寫出低耗能的執行緒安全單例呢 ？ 單例實現關鍵點 建構函式私有，

Qt下實現支援多執行緒的單例模式

1. 程式碼介紹 實現單例模式的程式碼很多。 本文的單例模式實現程式碼是本人一直在工程專案中使用的，現拿出和大家交流分享。 本文實現的單例模式，支援多執行緒，採用雙重校驗檢索的方式，整合析構類，杜絕記憶體洩漏，穩定性好。 使用C++/Qt的朋友們可以瞭解一下。 不再廢話，直接上程式碼。

日常小結-多執行緒的單例模式的三種實現方式

多執行緒單例模式在很多併發的書裡面都有寫。這裡做一個簡單的總結。主要內容來自《java併發程式設計的藝術》《java多執行緒程式設計核心》 單例模式的分類 餓漢模式：類初始化的時候就進行建立單例模式 懶漢模式：在呼叫getinstance方法的時候才建

執行緒安全(單例與多例)

      又週五了，時間過得好快，住在集體宿舍，幾個宅男共處一室好是無聊，習慣性來到CSDN。今天一個應屆生同事突然問我為什麼老大要求我們不要在Service裡寫成員變數，說不安全，說為什麼不安全讓他自己去了解，看上去他沒有找到頭緒很是痛苦，想想當初這個問題也困擾過自己，向

JAVA_多執行緒_單例模式

這篇是入職之後的第二篇了，上一篇我簡單介紹了一下LOCK裡面的類的方法，感興趣的話可以去了解一下，以後堅持每週至少會更新一篇關於多執行緒方面的文章，希望博友們可以一起加油成長。 這篇主要的內容是單例模式在多執行緒環境下的設計，這篇算是比較重要的內容，我會進行文字和程式碼的共同說明來講解記錄 1、立即載入（餓

【Java多執行緒】單例模式與多執行緒

單例模式大家都不陌生，即讓一個類只有一個例項。 單例模式分為懶漢式和餓漢式。 懶漢式☞方法呼叫時再例項化物件，什麼時候用什麼時候例項化，比較懶。 餓漢式☞方法呼叫前物件就已經建立好了，比較有捉急。 本文著重描述懶漢式與多執行緒的內容。 1.餓漢式 public

Java多執行緒之單例模式-yellowcong

我們常見的單利模式有餓漢式和懶漢式，懶漢式，就是在用的時候，再例項化物件，餓漢式，是還沒有開飯，就已經把物件例項化好了。在多執行緒開發中，解決單例的時候，有兩種解決方案，1、（懶漢式）同步程式碼塊

執行緒安全的單例模式也可以很精彩

這篇部落格以多種方式實現單例模式，包括非執行緒安全、執行緒安全的單例模式以及執行緒安全的優化。 餓漢式單例； 懶漢式單例(延遲初始化)；(執行緒不安全) 執行緒安全的單例-synchronized方法 執行緒安全的單例-同步程式碼塊

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

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

多執行緒呼叫單例類中的方法會不會造成執行緒安全問題

區域性變數不會受多執行緒影響 成員變數會受到多執行緒影響 多個執行緒應該是呼叫的同一個物件的同一個方法： 如果方法裡無成員變數，那麼不受任何影響 如果方法裡有成員變數，只有讀操作，不受影響                      存在寫操作，考慮多執行緒影響值 當多個執行

Java併發程式設計(3)-構造執行緒安全類的模式

文章目錄 一、例項限制模式 1.1、 限制變數確保執行緒安全 1.2、分析ArrayList的執行緒安全性 1.3、總結 二、委託執行緒安全模式 2.

muduo_base程式碼剖析之執行緒本地單例物件ThreadLocalSingleton

執行緒本地單例物件的封裝ThreadLocalSingleton<T>，也就是說，每一個執行緒都有一個T型別的單例物件 直接看測試程式碼 #include <muduo/base/ThreadLocalSingleton.h> #include &l

muduo_base程式碼剖析之執行緒安全的Sigleton模式

預備知識 什麼是單例模式？ 一個類有且僅有一個例項，並且對外提供統一的訪問該例項的介面 單例模式分為餓漢式、懶漢式，對於餓漢式要保證執行緒安全需要使用double-check lock機制 muduo中實現的執行緒安全的Sigleton類，沒使用鎖，而使用效率更高

執行緒安全的懶漢模式為什麼要使用volatile關鍵字

來看這樣一段程式碼，為什麼一定要用volatile關鍵字修飾instance變數呢？ public class Singleton{ private static volatile Singleton instance; private Singleton(){ }

單例模式之JAVA實現--如何實現真正的安全單例模式

單例模式 什麼是單例模式 單例模式屬於管理例項的創造型型別模式。單例模式保證在你的應用種最多隻有一個指定類的例項。 單例模式應用場景 專案配置類 讀取專案的配置資訊的類可以做成單例的，因為只需要讀取一次，且配置資訊欄位一般比較多節省資源。通過這個單例的類，