2. 程式人生 > >單列模式與多執行緒

單列模式與多執行緒

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

　在23個標準設計模式中，單例模式在應用中還是很常見的，但是在多執行緒環境中，單例模式的使用有非常多的坑，使用好單例模式的一個原則：如何使單例模式在遇到多執行緒的環境中是安全的、正確的。下面分析幾種多執行緒的實現方式以及遇到的坑。

一、立即載入/餓漢模式

　　立即載入：實用類的時候已經將物件建立完畢，常見的是直接new例項化，有“著急”，“急迫”的意思，因此也稱：“餓漢模式”。在呼叫方法前，已經例項化物件。程式碼如下：

單例模式：

複製程式碼

public class SingleTon01 {
    private  static SingleTon01 instance=new SingleTon01();

    public SingleTon01() {
        super();
    }
    public static SingleTon01 getInstance(){
        return instance;
    }
}

複製程式碼

執行緒：

複製程式碼

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(SingleTon01.getInstance().hashCode());
    }
}

複製程式碼

測試類：

複製程式碼

public class Run {
    public static void main(String[] args) {
        MyThread m1=new MyThread();
        MyThread m2=new MyThread();
        MyThread m3=new MyThread();
        MyThread m4=new MyThread();
        m1.start();
        m2.start();
        m3.start();
        m4.start();
    }
}

複製程式碼

執行結果：

　　所有執行緒的物件hashCode均是一樣的，證明是單例模式，but,該程式碼的實現是優缺點的：不能有其他例項變數，因為getInstance方法沒有同步，可能會出現執行緒安全問題。

二、延遲載入/懶漢模式

　　延遲載入：在呼叫方法的時候，物件才被例項化，常用的實現方式就是在方法內部例項化物件。程式碼如下：

單例模式：

複製程式碼

public class SingleTon02 {
    private  static SingleTon02 instance;

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

複製程式碼

執行緒類：

複製程式碼

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(SingleTon02.getInstance().hashCode());
    }
}

複製程式碼

測試類：

複製程式碼

public class Run {
    public static void main(String[] args) {
        MyThread m1=new MyThread();
        MyThread m2=new MyThread();
        MyThread m3=new MyThread();
        MyThread m4=new MyThread();
        m1.start();
        m2.start();
        m3.start();
        m4.start();
    }
}

複製程式碼

執行結果：

　　從執行結果來看，控制檯列印了多個hashCode值，說明該實現方式在多執行緒的環境中是失敗的，如何解決呢？其實很簡單，讓方法同步即可，使用synchronized關鍵字。改進後代碼吐下：

複製程式碼

public class SingleTon02 {
    private  static SingleTon02 instance;

    public SingleTon02() {
        super();
    }
    synchronized public static SingleTon02 getInstance(){
        try {
            if(null==instance){
                Thread.sleep(3000);//模擬業務處理
                instance=new SingleTon02();
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return instance;
    }
}

複製程式碼

再次執行：

　　同步之後，證明該單例模式是正確的。但是，這種方式又帶來一種缺點，那就是效率問題，因為下一個執行緒必須需要等上一個執行緒釋放鎖之後才能執行，需要排隊執行，因此還可以優化，那就是：嘗試同步程式碼塊，針對重要程式碼進行單獨同步，以提升效率。

　　下面總結了一種使用DCL雙檢查鎖機制實現單例模式，該模式適用於在多執行緒環境中的延遲載入單例模式設計。程式碼如下：

複製程式碼

public class SingleTon03 {
    private volatile static SingleTon03 instance;

    public SingleTon03() {
        super();
    }
    public static SingleTon03 getInstance(){
        try {
            if(null==instance){
                Thread.sleep(3000);//模擬業務處理
                synchronized (SingleTon03.class) {
                    if(null==instance){
                        instance=new SingleTon03();
                    }
                }
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return instance;
    }
}

複製程式碼

這種方式既保證了執行緒的安全性，還保證了效率。

 三、使用靜態內之類實現單例模式

　　前面的改進方式可以實現在多執行緒的環境中實現單例模式，並且保證執行緒安全，那麼這種靜態內建類的方式也可以實現同樣的效果。建立靜態內類，如下：

複製程式碼

public class SingleTon04 {
    private static class SingleInner{
        private static SingleTon04 instance=new SingleTon04();
    }

    public SingleTon04() {
        super();
    }
    
    public static SingleTon04 getInstance(){
        return SingleInner.instance;
    }
}

複製程式碼

執行緒類：

複製程式碼

public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(SingleTon04.getInstance().hashCode());
    }
}

複製程式碼

測試類同上

執行結果：

四、序列化與反序列化實現單例模式

　　靜態內建類固然可以實現單例模式，但是這裡有一個坑，那就是在遇到序列化和反序列化的時候，依然會出現問題，依然會出現多個例項化物件，程式碼如下：

單例模式

複製程式碼

public class SingleTon05 implements Serializable{

    private static final long serialVersionUID = 888888L;
    //內部類方式
    private static class SingleTonInner{
        private static final SingleTon05 instance=new SingleTon05();
    }
    public SingleTon05() {
        super();
    }
    public static SingleTon05 getInstance(){
        return SingleTonInner.instance;
    }
    
}

複製程式碼

序列化執行類：

複製程式碼

public class Run2 {
    public static void main(String[] args) {
        //寫
        try {
            SingleTon05 singleTon05=SingleTon05.getInstance();
            FileOutputStream out=new FileOutputStream(new File("singleton05.txt"));
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(out);
            
            objectOutputStream.writeObject(singleTon05);
            objectOutputStream.close();
            out.close();
            //列印hashcode
            System.out.println(singleTon05.hashCode());
        } catch (IOException e) {
            e.printStackTrace();
        }
        //讀
        try {
            FileInputStream in=new FileInputStream(new File("singleton05.txt"));
            ObjectInputStream objectInputStream=new ObjectInputStream(in);
            
            SingleTon05 singleTon05=(SingleTon05)objectInputStream.readObject();
            objectInputStream.close();
            in.close();
            //列印hashcode
            System.out.println(singleTon05.hashCode());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

複製程式碼

執行結果：

　　很明顯，寫入和讀出來的物件不是一個，顯然不符合單例模式的設計模式。序列化破壞了單例模式，當然，還有一種破壞單例模式的方式，那就是反射，單例模式中儘量不要使用反射。呢麼問題來了，如何改進呢，其實很簡單，在序列化的時候在呼叫一個方法。改進如下：

複製程式碼

public class SingleTon05 implements Serializable{

    private static final long serialVersionUID = 888888L;
    //內部類方式
    private static class SingleTonInner{
        private static final SingleTon05 instance=new SingleTon05();
    }
    public SingleTon05() {
        super();
    }
    public static SingleTon05 getInstance(){
        return SingleTonInner.instance;
    }
    protected Object readResolve()throws ObjectStreamException {
        System.out.println("呼叫了readResolve方法！");
        return SingleTonInner.instance;
    }
}

複製程式碼

再次執行：

　　序列化操作提供了一個很特別的鉤子（hook）-類中具有一個私有的被例項化的方法readresolve(),這個方法可以確保類的開發人員在序列化將會返回怎樣的object上具有發言權。這樣就確保我們在反序列化的時候返回的物件是同一個。

五、使用靜態程式碼塊實現單例模式

　　靜態程式碼塊中的程式碼執行實在實用類的時候載入，因此我們可以應用靜態程式碼塊的這種特性來設計單例模式。程式碼如下：

複製程式碼

public class SingleTon06{

    private static  SingleTon06 instance=null;
    public SingleTon06() {
        super();
    }
    static{
        instance=new SingleTon06();
    }
    public static SingleTon06 getInstance(){
        return instance;
    }
}

複製程式碼

執行緒類測試類同三，結果如下：

六、使用列舉實現單例模式

 　　因為列舉和靜態程式碼塊的特性有相似之處，因此也可以使用這種特性來設計單例模式，這種模式非常簡單，也推薦時使用。程式碼如下：

複製程式碼

public enum SingleTon07{
    INSTANCE;

    private SingleTon07() {
    }
    
    public static SingleTon07 getInstance(){
        return INSTANCE;
    }
    
}

複製程式碼

測試執行類同上，結果如下：

　　特點就是實現非常簡單。

瀋陽最好的胃腸醫院

煙臺哪個醫院做胃鏡檢查好

瀋陽做胃鏡多少錢

鄭州婦科醫院哪家好

相關推薦

單列模式與多執行緒

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

第六章單例模式與多執行緒——立即載入“餓漢模式”與延遲載入“懶漢模式”

立即載入就是使用類的時候已經將物件建立完畢了，也稱為“餓漢模式” package test01; public class MyObject { // 建立物件 private static MyObject object = new MyObject(); private MyObjec

Java多執行緒學習筆記21之單例模式與多執行緒

詳細程式碼見:github程式碼地址   第六章 單例模式與多執行緒 前言: 我之前已經開設了23個設計模式這個專欄，介紹了很多的Java設計模式，其中一些模式對於絕 大多數程式語言設計思想都是類似的，需要了解單例模式的可以去看看。 我們在實際開發中經常用到單例模式，但

單例模式與多執行緒之間的關係總結

給大家推薦個靠譜的公眾號程式設計師探索之路，大家一起加油 單例模式與多執行緒之間的關係總結（魔怔多執行緒中～～～～～） 　　近日筆者被多執行緒與單例物件之間的關係產生了混淆。通過了一段時間的查閱，理清了兩者之間的管理，現做筆記梳理。如有不足，歡迎指出:) 在我在考慮考慮他們的時候思考了以

Java多執行緒核心技術(五)單例模式與多執行緒

本文只需要考慮一件事：如何使單例模式遇到多執行緒是安全的、正確的 1.立即載入 / "餓漢模式" 什麼是立即載入？立即載入就是使用類的時候已經將物件建立完畢，常見的實現辦法就是直接 new 例項化。 public class MyObject { private static MyObject m

設計模式與多執行緒——用命令模式來設計多執行緒架構

下載原始碼   圖一 圖二 毫無疑問，多執行緒會增加寫程式碼的難度。在有併發處理的情況下，debug變得更困難，程式碼中的臨界區必須得到保護，共享的資源也得管理好。當然，通過增加程式執行的執行緒數帶來的結果是：效率可以大大提高。從一個程式設計師的角度來說，處理執行緒是

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

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

【多執行緒核心技術】---單例模式與多執行緒

立即載入/“餓漢模式”    立即載入就是在使用類的時候已經將物件建立完畢，常見的實現辦法就是直接new例項化。立即載入/“餓漢模式”    延遲載入就是在呼叫get（）方法時例項化才被建立，常見的實現方式就是在get（）方法中進行new（）例項化，    在多執行緒環境下會

設計模式初探之三------單例模式與多執行緒

單例模式：保證系統中一個類只有一個例項。即一個類只有一個物件例項  如何實現： 一是單例模式的類只提供私有的建構函式， 二是類定義中含有一個該類的靜態私有物件， 三是該類提供了一個靜態的公有的函式用於建立或獲取它本身的靜態私有物件。 以下是具體示例： 1、假設有一個企業名為

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

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

單例模式與多執行緒

如果一個類是單例類，那麼這個類只能例項化一個例項，並且單例類必須能夠自己建立自己的唯一例項（所以單例類的構造器必須是私有的）； 使用背景： 一個全域性使用的類頻繁地建立與銷燬，比如之前我曾負責人員電子檔案開發，這裡涉及到一個紅名單的概念，比如我們要檢視某

設計模式 - 單例模式之多執行緒除錯與破壞單例

前言 在之前的 設計模式 - 單例模式（詳解）看看和你理解的是否一樣？ 一文中，我們提到了通過Idea 開發工具進行多執行緒除錯、單例模式的暴力破壞的問題；由於篇幅原因，現在單獨開一篇文章進行演示：執行緒不安全的單例在多執行緒情況下為何被建立多個、如何破壞單例。 如果還不知道如何使用IDEA工具進行執行緒模

c#中委託與多執行緒的實質

delegate（委託）的概念，.Net的委託本質上就是指向函式的指標，只不過這種指標是經過封裝後型別安全的。委託和執行緒是兩個不同的概念，執行緒是動態的，委託就是一個或一組記憶體地址，是靜態的。執行緒執行時如果遇到了指向函式的指標就執行這個函式。.Net為了方便程式設計，給委託賦予了兩種方式以供呼

觀察者模式中多執行緒執行訂閱事件並順序執行的問題

       對事件釋出訂閱模式中啟動執行緒執行操作，但又要保證執行緒順序執行的一些思考和實踐，在開發過程中，經常會遇到需要使用事件來觸發方法執行的情況，比如CS中按鈕的點選事件，滑鼠移動事件，鍵盤監聽事件等等，有時候需要執行比較耗時的任務，但並不希望阻塞主執

爬蟲與多執行緒

多執行緒和多程序爬蟲   一.執行緒 1.什麼是執行緒。 執行緒是作業系統能夠進行運算排程的最小單位。它被包含在程序中，是進城中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個執行緒可以併發多個執行緒，每條執行緒執行不同的任務。   2.執行緒常用的方法

C語言高階篇 - 4.連結串列&狀態機與多執行緒

1.連結串列的引入 1、從陣列的缺陷說起         (1)陣列有2個缺陷，一個是陣列中所有元素的型別必須一致；第二個是陣列的元素個數必須事先制定並且一旦指定之後不能更改。         (2)如何解決

【Linux】多程序與多執行緒之間的區別

http://blog.csdn.net/byrsongqq/article/details/6339240 網路程式設計中設計併發伺服器，使用多程序與多執行緒 ，請問有什麼區別？  答案一: 1，程序：子程序是父程序的複製品。子程序獲得父程序資料空間、堆和棧的複製品。 2，執行緒：相

程序、執行緒與多執行緒

一、說說概念 1、程序（process） 狹義定義：程序就是一段程式的執行過程。 廣義定義：程序是一個具有一定獨立功能的程式關於某個資料集合的一次執行活動。它是作業系統動態執行的基本單元，在傳統的作業系統中，程序既是基本的分配單元，也是基本的執行單元。 簡單的來講程序的概念主

探討kafka的分割槽數與多執行緒消費

kafka算是很麻煩的一件事兒，起因是最近需要採集大量的資料，原先是隻用了典型的high-level Consumer的API，最經典的不過如下：   [java] view plain copy

Python佇列與多執行緒及檔案鎖

佇列實現生產-多執行緒消費 先看程式碼 # -*- coding: utf-8 -*- import queue import threading mu = threading.Lock() class Producer(threading.Thread): def __init__(