文章目錄

一、單例模式概述

（1）單例模式簡介
單例模式屬於創建型模式，所謂類的單例設計模式，就是採取一定的方法保證在整個的軟件系統中，對某個類只能存在一個對象實例，並且該類只提供一個取得其對象實例的方法(靜態方法)。

單例類只能有一個實例。
單例類必須自己創建自己的唯一實例。
單例類必須給所有其他對象提供這一實例。

比如Hibernate的SessionFactory，它充當數據存儲源的代理，並負責創建Session對象。SessionFactory並不是輕量級的，一般情況下，一個項目通常只需要一個SessionFactory就夠，這是就會使用到單例模式。

（2）單例模式優缺點
優點

在內存裏只有一個實例，減少了內存的開銷，尤其是頻繁的創建和銷燬實例（比如管理學院首頁頁面緩存）。
避免對資源的多重佔用（比如寫文件操作）。

缺點

沒有接口，不能繼承，與單一職責原則衝突，一個類應該只關心內部邏輯，而不關心外面怎麼樣來實例化。

（3）單例模式的實現方式

懶漢式，線程不安全
懶漢式，線程安全
餓漢式
雙檢鎖/雙重校驗鎖（DCL，即 double-checked locking）
登記式/靜態內部類
枚舉

二、懶漢式

1、線程不安全懶漢式

（1）線程不安全懶漢式示例

創建一個類，私有化該類的構造器，創建一個私有的靜態常量，並對外提供一個公有的靜態方法

/*線程不安全懶漢式*/
public class Singleton1 {
    /*私有化構造器*/
    private Singleton1(){}

    /*本類內部創建靜態常量*/
    private static Singleton1 singleton ;

    /*提供一個對外的公有的靜態方法，當使用到的時候才創建這個實例對象*/
    public static Singleton1 getSingleton() {
        if (singleton == null) {
            singleton = new Singleton1();
        }
        return singleton;
    }
}

main方法類

public class Lhs {
    public static void main(String[] args) {
        Singleton1 singleton1 = Singleton1.getSingleton();
        Singleton1 singleton2 = Singleton1.getSingleton();
        /*測試兩次獲取到的是否爲同一個實例*/
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

輸出結果

true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196

（2）線程不安全懶漢式分析

優缺點

起到了Lazy Loading的效果，但是只能在單線程下使用；
如果在多線程下，一個線程進入了if (singleton == null)判斷語句塊，還未來得及往下執行，另一個線程也通過了這個判斷語句，這時便會產生多個實例，所以在多線程環境下不可使用這種方式；
在實際開發中，不要使用這種方式。

2、線程安全懶漢式

（1）線程安全懶漢式示例

創建一個類，私有化該類的構造器，創建一個私有的靜態常量，並對外提供一個公有的靜態方法，同時需要在這個靜態方法上加上線程同步鎖，控制線程運行。

/*線程安全懶漢式*/
public class Singleton2 {
    /*私有化構造器*/
    private Singleton2(){}

    /*本類內部創建靜態常量*/
    private static Singleton2 singleton ;

    /*提供一個對外的公有的靜態方法，在方法上加入同步鎖synchronized*/
    public static synchronized Singleton2 getSingleton() {
        if (singleton == null) {
            singleton = new Singleton1();
        }
        return singleton;
    }
}

main方法類

public class Lhs {
    public static void main(String[] args) {
        Singleton2 singleton1 = Singleton2.getSingleton();
        Singleton2 singleton2 = Singleton2.getSingleton();
        /*測試兩次獲取到的是否爲同一個實例*/
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

輸出結果一致

true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196

（2）線程安全懶漢式分析

優缺點

解決了線程不安全問題；
效率太低了，每個線程在想獲得類的實例時候，執行getSingleton()方法都要進行同步。而其實這個方法只執行一次實例化代碼就夠了，後面的想獲得該類實例，直接return就行了，方法進行同步效率太低；
在實際開發中，不推薦使用這種方式。

3、同步代碼塊懶漢式

（1）同步代碼塊懶漢式示例

/*同步代碼塊餓漢式*/
public class Singleton3 {
    /*私有化構造器*/
    private Singleton3(){}

    /*本類內部創建靜態常量*/
    private static Singleton3 singleton ;

    /*提供一個對外的公有的靜態方法*/
    public static Singleton3 getSingleton() {
        if (singleton == null) {
            /*在創建實例出加上同步鎖*/
            synchronized(Singleton3.class) {
                singleton = new Singleton3();
            }
        }
        return singleton;
    }
}

main方法類

public class Lhs {
    public static void main(String[] args) {
        Singleton3 singleton1 = Singleton3.getSingleton();
        Singleton3 singleton2 = Singleton3.getSingleton();
        /*測試兩次獲取到的是否爲同一個實例*/
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

輸出結果一致

true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196

（2）同步代碼塊懶漢式分析

優缺點

這種方式，改爲同步產生實例化的的代碼塊，但是這種同步並不能起到線程同步的作用，假如一個線程進入了if (singleton == nul)判斷語句塊，還未來得及往下執行，另一個線程也通過了這個判斷語句，這時便會產生多個實例，會造成線程不安全的問題；
在實際開發中，不能使用這種方式

三、餓漢式

1、靜態常量餓漢式

（1）靜態常量餓漢式示例

新建一個類，將類的構造器私有化，在該類內部創建該類的實例，並對外提供公共的訪問方法以獲取該類的實例

/*靜態常量餓漢式*/
public class Singleton1 {
    /*私有化構造器*/
    private Singleton1(){}

    /*本類內部創建對象實例*/
    private final static Singleton1 singleton = new Singleton1();

    /*提供一個對外的公有的靜態方法，返回這個實例對象*/
    public static Singleton1 getSingleton(){
        return singleton;
    }
}

再main方法類中獲取該類的實例，可以得到，每次獲取到的都是同一個實例

public class Ehs {
    public static void main(String[] args) {
        Singleton1 singleton1 = Singleton1.getSingleton();
        Singleton1 singleton2 = Singleton1.getSingleton();
        /*測試兩次獲取到的是否爲同一個實例*/
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

輸出結果爲

true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196

（2）靜態常量餓漢式分析

優缺點

這種寫法比較簡單，就是在類裝載的時候就完成實例化，避免了線程同步問題；
沒有加鎖，執行效率會提高；
在類裝載的時候就完成實例化，沒有達到Lazy Loading的效果。如果從始至終從未使用過這個實例，則會造成內存的浪費；
這種方式基於classloder機制避免了多線程的同步問題，不過，singleton在類裝載時就實例化，在單例模式中大多數都是調用getSingleton方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式( 或者其他的靜態方法)導致類裝載，這時候初始化singleton就沒有達到lazy loading的效果；
這種單例模式可用，可能造成內存浪費。

2、靜態代碼塊餓漢式

（1）靜態代碼塊餓漢式示例

新建一個類，將類的構造器私有化，在該類內部創建一個靜態常量，並通過靜態代碼塊的方式才能關鍵類的實例賦予靜態常量，然後對外提供公共的訪問方法以獲取該類的實例

/*靜態代碼塊餓漢式*/
public class Singleton2 {
    /*私有化構造器*/
    private Singleton2(){}

    /*本類內部創建靜態變量*/
    private static Singleton2 singleton;

    /*靜態代碼塊中創建類的實例，並賦值給靜態變量*/
    static {
        singleton  = new Singleton2();
    }

    /*提供一個對外的公有的靜態方法，返回這個實例對象*/
    public static Singleton2 getSingleton(){
        return singleton;
    }
}

main方法類

public class Ehs {
    public static void main(String[] args) {
        Singleton2 singleton1 = Singleton2.getSingleton();
        Singleton2 singleton2 = Singleton2.getSingleton();
        /*測試兩次獲取到的是否爲同一個實例*/
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

輸出結果不變

true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196

（2）靜態代碼塊餓漢式分析

優缺點：

這種方式和上面的方式其實類似，只不過將類實例化的過程放在了靜態代碼塊中，也是在類裝載的時候，就執行靜態代碼塊中的代碼，初始化類的實例。
這種單例模式可用，但是可能造成內存浪費

四、雙檢鎖/雙重校驗鎖（Double Check）

1、雙檢鎖/雙重校驗鎖示例

創建一個類，私有化其構造器，聲明一個靜態常量，並加入volatile，對外提供一個公共訪問方法，加入雙重檢查鎖。

public class Singleton {
    /*靜態常量*/
    private volatile static Singleton singleton;
    
    /*私有化構造器*/
    private Singleton (){}
    
    /*共有方法，加入雙重檢查鎖*/
    public static Singleton getSingleton() {
        /*第一次檢查*/
        if (singleton == null) {
            synchronized (Singleton.class) {
                /*第二次檢查*/
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

main方法類

public class DoubleChecked {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getSingleton();
        Singleton singleton2 = Singleton.getSingleton();
        /*測試兩次獲取到的是否爲同一個實例*/
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

輸出結果爲

true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196

2、雙檢鎖/雙重校驗鎖分析

優缺點

Double-Check概念是多線程開發中常使用到的，如代碼中所示，我們進行了兩次if (singleton == null)檢查，這樣就可以保證線程安全了。這樣，實例化代碼只用執行一次，後面再次訪問時，判斷if (singleton == null),直接return實例化對象，也避免的反覆進行方法同步；
線程安全，延遲加載，效率較高；
在實際開發中，推薦使用這種單例設計模式。

五、登記式/靜態內部類

1、登記式/靜態內部類示例

創建一個類，私有化其構造器，在該類中設置一個靜態內部類並提供一個靜態屬性，然後對外需要提供一個公共的訪問方法

public class Singleton {
    /*私有化構造器*/
    private Singleton (){}

    /*靜態內部類，該類中有一個靜態屬性Singleton*/
    private static class SingletonHolder {
        private static final Singleton SINGLETON = new Singleton();
    }
    
    /*公共訪問方法，直接返回SINGLETON*/
    public static final Singleton getSingleton() {
        return SingletonHolder.SINGLETON;
    }
}

main方法類

public class Jtlbl {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getSingleton();
        Singleton singleton2 = Singleton.getSingleton();
        /*測試兩次獲取到的是否爲同一個實例*/
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

輸出結果爲

true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196

2、登記式/靜態內部類分析

優缺點

這種方式採用了類裝載的機制來保證初始化實例時只有一個線程。
靜態內部類方式在Singleton類被裝載時並不會立即實例化，而是在需要實例化時，調用getSingleton方法，纔會裝載SingletonHolder類，從而完成Singleton的實例化。
類的靜態屬性只會在第一次加載類的時候初始化，所以在這裏，JVM幫助我們保證了線程的安全性，在類進行初始化時，別的線程是無法進入的。
避免了線程不安全，利用靜態內部類特點實現延遲加載，效率高
一般推薦使用該方法

六、枚舉

1、枚舉示例

創建一個枚舉類

public enum Singleton {
    INSTANCE;   //屬性
    public void enumMethod() {
        System.out.println("枚舉式單例模式");
    }
}

main方法類

public class MJ {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.INSTANCE;
        Singleton singleton2 = Singleton.INSTANCE;
        /*測試兩次獲取到的是否爲同一個實例*/
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());

        singleton1.enumMethod();
        singleton2.enumMethod();
    }
}

輸出結果爲

true
singleton1的hashCode = 22307196
singleton2的hashCode = 22307196
枚舉式單例模式
枚舉式單例模式

2、枚舉分析

優缺點

這藉助JDK1.5中添加的枚舉來實現單例模式。不僅能避免多線程同步問題，而且還能防止反序列化重新創建新的對象；
這種方式是Effective Java作者Josh Bloch提倡的方式，一般推薦使用。

七、單例模式使用注意事項

單例模式保證了系統內存中該類只存在一個對象，節省了系統資源，對於一些需要頻繁創建銷燬的對象，使用單例模式可以提高系統性能；
當想實例化一個單例類的時候，必須要記住使用相應的獲取對象的方法，而不是使用new；
單例模式使用的場景:需要頻繁的進行創建和銷燬的對象、創建對象時耗時過多或耗費資源過多(即:重量級對象)，但又經常用到的對象、工具類對象、頻繁訪問數據庫或文件的對象(比如數據源、session工廠等)；

JAVA 設計模式（二）—— 單例模式

文章目錄

一、單例模式概述

二、懶漢式

1、線程不安全懶漢式

（1）線程不安全懶漢式示例

（2）線程不安全懶漢式分析

2、線程安全懶漢式

（1）線程安全懶漢式示例

（2）線程安全懶漢式分析

3、同步代碼塊懶漢式

（1）同步代碼塊懶漢式示例

（2）同步代碼塊懶漢式分析

三、餓漢式

1、靜態常量餓漢式

（1）靜態常量餓漢式示例

（2）靜態常量餓漢式分析

2、靜態代碼塊餓漢式

（1）靜態代碼塊餓漢式示例

（2）靜態代碼塊餓漢式分析

四、雙檢鎖/雙重校驗鎖（Double Check）

1、雙檢鎖/雙重校驗鎖示例

2、雙檢鎖/雙重校驗鎖分析

五、登記式/靜態內部類

1、登記式/靜態內部類示例

2、登記式/靜態內部類分析

六、枚舉

1、枚舉示例

2、枚舉分析

七、單例模式使用注意事項

Shell/Python中的用戶名獲取

JavaScript（一）—— JavaScript 基礎語法（標籤、輸出、註釋、關鍵字、變量、數據類型及轉換、運算符）

JAVA 數據結構與算法（五）—— 樹結構之二叉樹

JAVA 數據結構與算法（三）—— 查找算法（順序/線性查找、二分查找/折半查找、插值查找、斐波那契查找）

JAVA 數據結構與算法（四）—— 哈希算法

JAVA 數據結構與算法（二）—— 排序算法（冒泡、選擇、插入、希爾、快速、歸併、計數、基數、堆排序和桶排序）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結