Java多線程核心技術(五)單例模式與多線程

阿新 • • 發佈：2018-09-20

otf 實現 https 但是 not hashcode int 線程編程代碼包

本文只需要考慮一件事：如何使單例模式遇到多線程是安全的、正確的

1.立即加載 / "餓漢模式"

什麽是立即加載？立即加載就是使用類的時候已經將對象創建完畢，常見的實現辦法就是直接 new 實例化。

public class MyObject {
    private static MyObject myObject = new MyObject();

    public MyObject(){

    }

    public static MyObject getInstance(){
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

打印結果：

985396398
985396398
985396398

控制臺打印的 hashCode 是同一個值，說明對象是同一個，也就實現了立即加載型單例設計模式。

此版本的缺點是不能有其他其他實例變量，因為getInstance()方法沒有同步，所以有可能出現非線程安全問題。

2.延遲加載 / "懶漢模式"

什麽是延遲加載？延遲加載就是在調用 get() 方法時實例才被創建，常見的實現方法就是在 get() 方法中進行 new() 實例化。

測試代碼：

public class MyObject {
    private static MyObject myObject;

    public MyObject() {

    }

    public static MyObject getInstance() {
        try {
            if (myObject == null) {
                //模擬對象在創建之前做的一些準備工作
                Thread.sleep(3000);
                myObject = new MyObject();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

打印結果：

985396398
610025186
21895028

從運行結果來看，創建了三個對象，並不是真正的單例模式。原因顯而易見，3個線程同時進入了if (myObject == null) 判斷語句中，最後各自都創建了對象。

3.延遲加載解決方案

3.1 聲明synchronized關鍵字

既然多個線程可以同時進入getInstance() 方法，那麽只需要對其進行同步synchronized處理即可。

public class MyObject {
    private static MyObject myObject;

    public MyObject() {

    }

    synchronized public static MyObject getInstance() {
        try {
            if (myObject == null) {
                //模擬對象在創建之前做的一些準備工作
                Thread.sleep(3000);
                myObject = new MyObject();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

打印結果：

961745937
961745937
961745937

雖然運行結果表明，成功實現了單例，但這種給整個方法上鎖的解決方法效率太低。

3.2 嘗試同步 synchronized 代碼塊

同步方法是對方法的整體加鎖，這對運行效率來講很不利的。改成同步代碼塊後：

public class MyObject {
    private static MyObject myObject;

    public MyObject() {

    }

    public static MyObject getInstance() {
        try {
            synchronized (MyObject.class) {
                if (myObject == null) {
                    //模擬對象在創建之前做的一些準備工作
                    Thread.sleep(3000);
                    myObject = new MyObject();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

打印結果：

355159803
355159803
355159803

運行結果雖然表明是正確的，但同步synchronized語句塊依舊把整個 getInstance()方法代碼包括在內，和synchronize 同步方法效率是一樣低下。

3.3 針對某些重要的代碼進行單獨同步

所以，我們可以針對某些重要的代碼進行單獨的同步，而其他的代碼則不需要同步。這樣在運行時，效率完全可以得到大幅度提升。

public class MyObject {
    private static MyObject myObject;

    public MyObject() {

    }

    public static MyObject getInstance() {
        try {
            if (myObject == null) {
                //模擬對象在創建之前做的一些準備工作
                Thread.sleep(3000);
                synchronized (MyObject.class) {
                    myObject = new MyObject();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

運行結果：

985396398
21895028
610025186

此方法只對實例化對象的關鍵代碼進行同步，從語句的結構上來說，運行的效率的確得到的提升。但是在多線程的情況下依舊無法解決得到一個單例對象的結果。

3.4 使用DCL雙檢查鎖機制

在最後的步驟中，使用DCL雙檢查所=鎖機制來實現多線程環境中的延遲加載單例設計模式。

public class MyObject {
    private volatile static MyObject myObject;

    public MyObject() {

    }

    public static MyObject getInstance() {
        try {
            if (myObject == null) {
                //模擬對象在創建之前做的一些準備工作
                Thread.sleep(3000);
                synchronized (MyObject.class) {
                    if (myObject == null) {
                        myObject = new MyObject();
                    }
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return myObject;
    }


    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

運行結果：

860826410
860826410
860826410

使用DCL雙重檢查鎖功能，成功地解決了“懶漢模式”遇到多線程的問題。DCL也是大多數多線程結合單例模式使用的解決方案。

4.使用靜態內置類實現單例模式

DCL可以解決多線程單例模式的非線程安全問題。當然，還有許多其它的方法也能達到同樣的效果。

public class MyObject {
    public static class  MyObjectHandle{
        private static MyObject myObject = new MyObject();
        public static MyObject getInstance() {
            return myObject;
        }
    }

    public static MyObject getInstance(){
        return MyObjectHandle.getInstance();
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }
}

打印結果：

1035057739
1035057739
1035057739

靜態內置類可以達到線程安全問題，但如果遇到序列化對象時，使用默認的方式運行得到的結果還是多例的。

解決方法就是在反序列化中使用readResolve()方法：

public class MyObject implements Serializable {
    //靜態內部類
    public static class  MyObjectHandle{
        private static final MyObject myObject = new MyObject();
    }

    public static MyObject getInstance(){
        return MyObjectHandle.myObject;
    }

    protected Object readResolve(){
        System.out.println("調用了readResolve方法");
        return MyObjectHandle.myObject;
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        MyObject myObject = MyObject.getInstance();
        FileOutputStream outputStream = new FileOutputStream(new File("myObject.txt"));
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(myObject);
        objectOutputStream.close();
        System.out.println(myObject.hashCode());
        
        FileInputStream inputStream =  new FileInputStream(new File("myObject.txt"));
        ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
        MyObject object = (MyObject) objectInputStream.readObject();
        objectInputStream.close();
        System.out.println(object.hashCode());
    }
}

運行結果：

621009875
調用了readResolve方法
621009875

5.使用static代碼塊實現單例模式

靜態代碼塊中的代碼在使用類的時候就已經執行了，所以可以應用靜態代碼塊的這個特點來實現單例設計模式。

public class MyObject {
    private static MyObject myObject = null;
    static {
        myObject = new MyObject();
    }
    public static MyObject getInstance(){
        return myObject;
    }
    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

運行結果：

355159803
355159803
355159803

6.使用enum枚舉數據類型實現單例模式

枚舉enum 和靜態代碼塊的特性相似，在使用枚舉類時，構造方法會被自動調用，也可以應用其這個特性實現單例設計模式。

public enum Singleton {
    INSTANCE;
    private MyObject myObject = null;
    Singleton() {
        myObject = new MyObject();
    }
    public MyObject getInstance(){
        return myObject;
    }

    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Singleton.INSTANCE.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Singleton.INSTANCE.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Singleton.INSTANCE.getInstance().hashCode());
            }
        }).start();
    }
}

運行結果：

1516133987
1516133987
1516133987

這樣實現的一個弊端就是違反了“職責單一原則”，完善後的代碼如下：

public class MyObject {
    public enum Singleton {
        INSTANCE;
        private MyObject myObject = null;

        Singleton() {
            myObject = new MyObject();
        }

        public MyObject getInstance() {
            return myObject;
        }
    }

    public static MyObject getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    public static void main(String[] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(MyObject.getInstance().hashCode());
            }
        }).start();
    }

}

運行結果：

610025186
610025186
610025186

7.文末總結

本文使用若幹案例來闡述單例模式與多線程結合遇到的情況與解決方案。

參看

《Java多線程編程核心技術》高洪巖著

擴展

Java多線程編程核心技術(一)Java多線程技能

Java多線程編程核心技術(二)對象及變量的並發訪問

Java多線程編程核心技術(三)多線程通信

Java多線程核心技術(四)Lock的使用

Java多線程核心技術(五)單例模式與多線程

otf 實現 https 但是 not hashcode int 線程編程代碼包本文只需要考慮一件事：如何使單例模式遇到多線程是安全的、正確的 1.立即加載 / "餓漢模式" 什麽是立即加載？立即加載就是使用類的時候已經將對象創建完畢，常見的實現

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

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

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

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

《JAVA多線程編程核心技術》筆記：第六章：單例模式與多線程

會有 isp left sync con 多線程編程鎖機制數據 range 一、立即加載/"餓漢模式"和延遲加載/"懶漢模式" 立即加載（又稱餓漢模式）：在使用類的時候已經將對象創建完畢，常見實現方法是直接new實例化延遲加載（又稱懶漢模式）：在調用get

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

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

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

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

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

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

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

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

單例模式與多例模式

按照java與模式的作者閻巨集的說法：實現上有餓漢式單例類和懶漢式單例類之分，我感覺，這種說法，簡直太形象了。不知道，閻先生是怎樣想到的。餓漢模式下，在變數域中就將其例項化，可謂是未雨而綢繆；懶漢模式下，什麼時候用，什麼時候再例項化。單例模式的三個特點：單例類只能有

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

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

單例模式與多執行緒

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

Java多執行緒核心技術(五)：定時器Timer

Timer類主要負責計劃任務的功能，也就是在指定的時間開始執行某一個任務。 1、schedule(TimerTask task,Date time) 方法schedule(TimerTask task,Date time)的作用是在指定的日期執行一次某一任務。如下程式碼是

Java面試題之在多線程情況下，單例模式中懶漢和餓漢會有什麽問題呢？

餓漢模式問題之間 static 代碼 clas ava public 餓漢懶漢模式和餓漢模式： public class Demo { //private static Single single = new Single();//餓漢模式

“全棧2019”Java多線程第二十五章：生產者與消費者線程詳解

工程 java 技術分享初級計劃公眾圖片進步 www. 難度初級學習時間 10分鐘適合人群零基礎開發語言 Java 開發環境 JDK v11 IntelliJ IDEA v2018.3 文章原文鏈接 “全棧2019”Java多線程第二十五章：生產者與

你所不知道的單例模式和多線程並發在單例模式中的影響

影響編程問題 rop key 是我提升註意特性是不是單例對象（Singleton）是一種常用的設計模式。在Java應用中，單例對象能保證在一個JVM中，該對象只有一個實例存在。這樣的模式有幾個好處： 1、某些類創建比較頻繁，對於一些大型的對象，這是一筆很大的系

Java多執行緒核心技術(六)執行緒組與執行緒異常

本文應注重掌握如下知識點：執行緒組的使用如何切換執行緒狀態 SimpleDataFormat 類與多執行緒的解決辦法如何處理執行緒的異常 1.執行緒的狀態執行緒物件在不同執行時期有不同的狀態，狀態資訊就處於State列舉類中，如圖所示：執行緒狀態初始(NEW)：新建立了一個執行緒物件，但還

單例模式與線程安全問題淺析

ati 多線程 con data 非常完美賦值 return span author 近期看到到Struts1與Struts2的比較。說Struts1的控制器是單例的，線程不安全的；Struts2的多例的，不存在線程不安全的問題。之後又想到了之前自

1、Spring單例模式與線程安全

局部變量提醒業務 bean 環境 protect 線程安全問題 for 最快引自：https://www.cnblogs.com/wxd0108/p/5524756.html 一、問題背景這段時間在做項目的時候，考慮到Spring中的bean默認是單例模式的，那麽當

Java 多執行緒（四）—— 單例模式

這篇部落格介紹執行緒安全的應用——單例模式。單例模式單例模式，是一種常用的軟體設計模式。在它的核心結構中只包含一個被稱為單例的特殊類。通過單例模式可以保證系統中，應用該模式的類一個類只有一個例項。即一個類只有一個物件例項。例項: /** * @author

關於JAVA你必須知道的那些事（四）：單例模式和多型

好吧，今天一定要把面向物件的最後一個特性：多型，給說完。不過我們先來聊一聊設計模式，因為它很重要。設計模式官方的解釋是，設計模式是：一套被反覆使用，多數人知曉的，經過分類編目，程式碼設計經驗的總結。說人話就是：軟體開發人員在軟體開發過程中面臨的一般問題的解決方案。常見的設計模式可以

Java多線程核心技術(五)單例模式與多線程

1.立即加載 / "餓漢模式"

2.延遲加載 / "懶漢模式"

3.延遲加載解決方案

3.1 聲明synchronized關鍵字

3.2 嘗試同步 synchronized 代碼塊

3.3 針對某些重要的代碼進行單獨同步

3.4 使用DCL雙檢查鎖機制

4.使用靜態內置類實現單例模式

5.使用static代碼塊實現單例模式

6.使用enum枚舉數據類型實現單例模式

7.文末總結

參看

擴展

相關推薦