單例模式的7種實現方式及分析

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

第一種

程式碼

package com.xiayc.singleton;

/**
 * 餓漢模式
 * @author xyc
 *
 */
public class Hungry {
    private Hungry() {

    }

    private volatile static Hungry singleton = new Hungry();

    public static Hungry getSingleton() {
        return singleton;
    }

    public static void main(String[] args) {
        for 
 (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Hungry.getSingleton());
                }
            }).start();
        }
    }
}

執行結果

com.xiayc.singleton.Hungry@1ea452f5
com 
.xiayc.singleton.Hungry@1ea452f5
com.xiayc.singleton.Hungry@1ea452f5
com.xiayc.singleton.Hungry@1ea452f5
com.xiayc.singleton.Hungry@1ea452f5
com.xiayc.singleton.Hungry@1ea452f5
com.xiayc.singleton.Hungry@1ea452f5
com.xiayc.singleton.Hungry@1ea452f5
com.xiayc.singleton.Hungry@1ea452f5
com.xiayc.singleton 
.Hungry@1ea452f5

分析

例項變數的hashCode值一致，說明物件是同一個，餓漢式單例實現是執行緒安全的，
缺點是該類載入的時候就會直接new 一個靜態物件出來，當系統中這樣的類較多時，會使得啟動速度變慢，且不符合懶載入思想。

第二種

程式碼

package com.xiayc.singleton;

/**
 * 懶漢模式
 * @author xyc
 *
 */
public class Lazy {
    private Lazy() {

    }

    private volatile static Lazy singleton = null;

    public static Lazy getSingleton() {
        if(singleton==null) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleton = new Lazy();
        }
        return singleton;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Lazy.getSingleton());
                }
            }).start();
        }
    }
}

執行結果

com.xiayc.singleton.Lazy@1ea452f5
com.xiayc.singleton.Lazy@7ec5aaaa
com.xiayc.singleton.Lazy@c16150
com.xiayc.singleton.Lazy@1d49826
com.xiayc.singleton.Lazy@423430c8
com.xiayc.singleton.Lazy@58bb45bd
com.xiayc.singleton.Lazy@277ea783
com.xiayc.singleton.Lazy@40d9c054
com.xiayc.singleton.Lazy@27958c7
com.xiayc.singleton.Lazy@50d03d7f

分析

例項變數的hashCode值不一致，說明物件不是同一個，懶漢式單例實現是非執行緒安全的。
優點是實現了懶載入思想。

第三種

程式碼

package com.xiayc.singleton;

public class SyncMethodLazy {
    private SyncMethodLazy() {

    }

    private static SyncMethodLazy singleton = null;

    public static synchronized SyncMethodLazy getSingleton() {
        if(singleton==null) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleton = new SyncMethodLazy();
        }
        return singleton;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(SyncMethodLazy.getSingleton());
                }
            }).start();
        }
    }
}

執行結果

com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054
com.xiayc.singleton.SyncMethodLazy@40d9c054

分析

例項變數的hashCode值一致，說明物件是同一個，使用synchronized關鍵字的懶漢式單例實現是執行緒安全的。
優點是實現了執行緒安全並且是懶載入的；缺點是在同一時刻getSingleton方法只能由一個執行緒訪問，效率會很低。

第四種

程式碼

package com.xiayc.singleton;

public class SyncFullCodeBlockLazy {
    private SyncFullCodeBlockLazy() {

    }

    private static SyncFullCodeBlockLazy singleton = null;

    public static SyncFullCodeBlockLazy getSingleton() {
        synchronized (SyncFullCodeBlockLazy.class) {
            if(singleton==null) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                singleton = new SyncFullCodeBlockLazy();
            }
            return singleton;
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(SyncFullCodeBlockLazy.getSingleton());
                }
            }).start();
        }
    }
}

執行結果

com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5          com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5      com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5      com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5          com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5          com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5          com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5          com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5          com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5          com.xiayc.singleton.SyncFullCodeBlockLazy@1ea452f5

分析

例項變數的hashCode值一致，說明物件是同一個，使用synchronized關鍵字修飾全部程式碼塊的懶漢式單例實現是執行緒安全的。
這種實現方式其實和synchronized修飾方法的實現方式優缺點一致。

第五種

程式碼

package com.xiayc.singleton;

public class SyncPartCodeBlockLazy {
    private SyncPartCodeBlockLazy() {

    }

    private static SyncPartCodeBlockLazy singleton = null;

    public static SyncPartCodeBlockLazy getSingleton() {
        if(singleton==null) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (SyncPartCodeBlockLazy.class) {
                singleton = new SyncPartCodeBlockLazy();
            }
        }
        return singleton;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(SyncPartCodeBlockLazy.getSingleton());
                }
            }).start();
        }

    }
}

執行結果

com.xiayc.singleton.SyncPartCodeBlockLazy@7ec5aaaa
com.xiayc.singleton.SyncPartCodeBlockLazy@1d49826   com.xiayc.singleton.SyncPartCodeBlockLazy@277ea783  com.xiayc.singleton.SyncPartCodeBlockLazy@50d03d7f  com.xiayc.singleton.SyncPartCodeBlockLazy@58bb45bd  com.xiayc.singleton.SyncPartCodeBlockLazy@1ea452f5  com.xiayc.singleton.SyncPartCodeBlockLazy@27958c7       com.xiayc.singleton.SyncPartCodeBlockLazy@423430c8      com.xiayc.singleton.SyncPartCodeBlockLazy@40d9c054      com.xiayc.singleton.SyncPartCodeBlockLazy@c16150

分析

例項變數的hashCode值不一致，說明物件不是同一個，使用synchronized關鍵字修飾區域性程式碼塊的懶漢式單例實現是非執行緒安全的。
雖然這種實現方法相較於第三種和第四種方式效率要高一些，但並非執行緒安全的。

第六種

程式碼

package com.xiayc.singleton;

public class SyncDoubleCheckLazy {
    private SyncDoubleCheckLazy() {

    }

    private static SyncDoubleCheckLazy singleton = null;

    public static SyncDoubleCheckLazy getSingleton() {
        if(singleton==null) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (SyncDoubleCheckLazy.class) {
                if(singleton==null) {
                    singleton = new SyncDoubleCheckLazy();
                }
            }
        }
        return singleton;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(SyncDoubleCheckLazy.getSingleton());
                }
            }).start();
        }
    }
}

執行結果

com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8

分析

例項變數的hashCode值不一致，說明物件不是同一個，使用synchronized關鍵字雙重檢查的懶漢式單例實現是執行緒安全的。
其實這種方式是綜合了第三、四、五這三種實現方式，即實現了執行緒安全，也相對提高了執行效率，值得推薦。

第七種

程式碼

package com.xiayc.singleton;

public class StaticInnerClass {
    private StaticInnerClass() {

    }

    private static class StaticInnerClassProvider{  
        private static StaticInnerClass singleton = new StaticInnerClass();  
    }

    public static StaticInnerClass getSingleton() {
        return StaticInnerClassProvider.singleton;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(StaticInnerClass.getSingleton());
                }
            }).start();
        }
    }
}

執行結果

com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8
com.xiayc.singleton.SyncDoubleCheckLazy@423430c8

分析

例項變數的hashCode值不一致，說明物件不是同一個，使用靜態內部類方式的懶漢式單例實現是執行緒安全的。
雖然咋看上去這種方式和第一種餓漢模式的單例模式一樣，兩者都是採用了類裝載的機制來保證初始化例項時只有一個執行緒，但是有區別的地方在於靜態內部類方式在StaticInnerClass類被裝載時並不會立即例項化，而是在需要例項化時，呼叫getInstance方法，才會裝載StaticInnerClassProvider類，從而完成StaticInnerClass的例項化，所以這種方式也值得推薦。

Android 單例模式幾種實現方式及簡析

一.定義：確保某一個類只有一個例項，而且自行例項並向整個系統提供這個例項二.使用場景：避免產生過多的物件消耗過多的資源，或者某種型別的物件只應該有且只有一個。例如，建立一個物件需要消耗的資源過多，如訪問資料庫或者IO 資源。三.實現單例模式的關鍵

單例模式的7種實現方式及分析

第一種程式碼 package com.xiayc.singleton; /** * 餓漢模式 * @author xyc * */ public class Hungry {

單例模式幾種實現方式

size ron jdk null singleton bsp 還要一個 fin 1、餓漢式：靜態常量特點：單例的實例被聲明成static和final變量了，在第一次加載類到內存中時就會初始化，所以會創建實例本身是線程安全的 public class Sin

Java單例模式幾種實現方式

開始名稱常量就是多線程開發靜態代碼塊浪費 ack 多線程同步在平時的工作、學員的學習以及面試過程中，單例模式作為一種常用的設計模式，會經常被面試官問到，甚至筆試會要求學員現場默寫，下面將會就單例模式的實現思路和幾種常見的實現方式進行簡單的分享。

單例模式6種實現方式

一：餓漢式public class MyObject { // 立即載入方式==餓漢模式 private static MyObject myObject = new MyObject();

單例模式——六種實現方式（懶漢、餓漢、雙重檢驗鎖、靜態內部類、列舉）

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

c#單例模式兩種實現方式

//單例模式一，本模式具有多執行緒不安全性，可通過多執行緒鎖來實現功能 public class Class1 { //(1)將建構函式定義為private private Class1() {

單例的兩種實現方式、多個版本及利弊對照

單例設計模式，顧明思議，只有一個例項，先交代重要一點，為防止外界對該類進行例項化，需要把類的建構函式宣告為私有的，這樣大家對原理理解更深入些。 1、餓漢式餓漢模式單例程式碼，經典，可用，無需改進。 package com.sing

單例模式6種實現及利弊分析

[TOC] # 單例模式6種實現及利弊分析單例模式三要素 - **私有的構造方法；** - **指向自己例項的私有靜態引用；** - **以自己例項為返回值的靜態的公有方法** ## **1.餓漢式** ```java public class Singleton { private

單例的三種實現方式

In imp SQ span wrap 定制 bsp () import 一：類方法實現單例 class Mysql: __instance = None def __init__(self,host,port): self.ho

C++之智慧指標和普通指標單例模式兩種實現

1 問題實現c++的單例模式，這裡測試分別寫了通過智慧指標返回物件和普通返回指標 2 程式碼測試 include <iostream> #include <mutex> #include <m

單例模式兩種建立方式

在建立單例模式的時候，如果單純的只考慮單例而不思考那樣做的話會產生什麼問題這樣是不嚴謹的，比如會發生執行緒安全問題，看了一些文章其中一篇寫得非常詳細有關單例模式的問題和效能比較，這篇文章http://blog.sina.com.cn/s/blog_62c7c3030100zw

高併發下最全執行緒安全的單例模式幾種實現

為了節約系統資源，有時需要確保系統中某個類只有唯一一個例項，當這個唯一例項建立成功之後，我們無法再建立一個同類型的其他物件，所有的操作都只能基於這個唯一例項。但是餓漢式單例類不能實現延遲載入，不管將來用不用始終佔據記憶體；懶漢式單例類執行緒安全控制煩瑣，而且效能受影響。可

單例模式7種寫法

第一種（懶漢，執行緒不安全）： 1 publicclass Singleton { 2 privatestatic Singleton instance; 3 privateSingleton (){} 4 publicstatic Single

python單例模式三種實現方法

1.方法1，程式執行過程中，某個類物件只有1個，該類物件的例項物件可以有無數個，根絕這點，讓類物件持有一個例項化物件，重寫類物件的__new__方法，始終返回持有的這個例項化物件，即可實現單例模式。 class Person1: _single = None

單例模式的多種實現方式

相對於第三種方式，這種方式是Singleton類被裝載了，instance不一定被初始化。因為SingletonHolder類沒有被主動使用，只有顯式通過呼叫getInstance方法時，才會顯式裝載SingletonHolder類，從而例項化instance。例如，如果例項化instance很消耗資源，我

Java 單例模式幾種實現的差別

單例模式確保某個類只有一個例項，而且自行例項化並向整個系統提供這個例項。思路是通過將該類的構造方法設為private，那麼在其他類中不能直接例項化該類。那麼為了得到該類的例項，需要有public的static方法來返回該類的例項。（之所以static是為了可以直接用

單例模式的兩種實現方式及區別

1:類載入時進行物件的例項化: public class SingletonA { //SingletonA的唯一例項 private static SingletonA instance = new SingletonA(); //將建構函式私有，防止外界構造Sin

單例模式的幾種實現方式及對比

所謂單例就是在系統中只有一個該類的例項。單例模式的核心分以下三個步驟：構造方法私有化。即不能在類外例項化，只能在類內例項化。在本類中建立本類的例項。在本類中提供給外部獲取例項的方式。單例模式的實現方式有兩種：餓漢模式和懶漢模式。餓漢模式不管現

單例模式的五種實現方式及優缺點

> **公號：碼農充電站pro** > **主頁：** 當我們需要使得某個類只能有一個例項時，可以使用**單例模式**。 **單例模式**（*Singleton Design Pattern*）保證一個類只能有一個例項，並提供一個全域性訪問點。單例模式的實現需要**三個必要的條件**： 1. 單例類

單例模式的7種實現方式及分析

相關推薦