什么是Singleton？

Singleton：在Java中即指單例設計模式，它是軟件開發中最常用的設計模式之一。

單：指唯一

例：指實例

單例設計模式，即某個類在整個系統中只能有一個實例對象可被獲取和使用的代碼模式。

要點：

一、單例類只能有一個實例

• 保證構造器私有化（防止通過構造器實例化）

二、單例類必須自信創建這個實例

• 在單例類中創建一個靜態變量來保存這個唯一的實例

三、單例類必須自行向整個系統提供這個實例

• 對外提供該實例對象的獲取方式

1. 直接暴露該實例對象
2. 用靜態變量的get方法獲取該實例對象

 

單例的幾種常見形式

餓漢式：直接創建對象，不存在線程安全問題

• 直接實例化餓漢式（簡介直觀）

/**
 * 單例餓漢式一（1）
 * 直接實例化餓漢式（簡潔直觀）
 * 對外提供獲取該實例對象的方式：
 * （1）直接暴露
 * （2）用靜態變量的get方法獲取
 */
public class SingletonHungry1 {

    public static final SingletonHungry1 INSTANCE = new SingletonHungry1();

    private SingletonHungry1() {}
}


/**
 * 單例餓漢式一（2）
 * 直接實例化餓漢式（簡潔直觀）
 * 對外提供獲取該實例對象的方式：
 * （1）直接暴露
 * （2）用靜態變量的get方法獲取
 */
public class SingletonHungry2 {

    private static final SingletonHungry2 INSTANCE = new SingletonHungry2();

    private SingletonHungry2() {}

    public static SingletonHungry2 getInstance() {
        return INSTANCE;
    }
}

• 枚舉式（最簡潔）

/**
 * 單例餓漢式二
 * 枚舉式（最簡潔）
 */
public enum SingletonHungry3 {
    INSTANCE
}

• 靜態代碼塊餓漢式（適合復雜實例化）

/**
 * 單例餓漢式三
 * 靜態代碼塊餓漢式（適合復雜實例化）
 */
public class SingletonHungry4 {

    public static final SingletonHungry4 INSTANCE;

    private String info;

    static {
        // 這里用來實現復雜的實例化
        // ......復雜代碼
        try {
            Properties pro = new Properties();
            pro.load(SingletonHungry4.class.getClassLoader().getResourceAsStream("singleton.properties"));
            INSTANCE = new SingletonHungry4(pro.getProperty("info"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private SingletonHungry4(String info) {
        this.info = info;
    }
}

 

懶漢式：延遲創建對象

• 線程不安全（適用於單線程）

/**
 * 單例懶漢式一
 * 線程不安全（適用於單線程）
 */
public class SingletonLazy1 {

    private static SingletonLazy1 INSTANCE;

    private SingletonLazy1() {}

    public static SingletonLazy1 getInstance() {
        if (INSTANCE == null) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new SingletonLazy1();
        }
        return INSTANCE;
    }
}

• 線程安全（適用於多線程）

/**
 * 單例懶漢式二（1）
 * 線程安全（適用於多線程）
 */
public class SingletonLazy2 {

    private static SingletonLazy2 INSTANCE;

    private SingletonLazy2() {}

    public static SingletonLazy2 getInstance() {
        synchronized (SingletonLazy2.class) {
            if (INSTANCE == null) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new SingletonLazy2();
            }
        }
        return INSTANCE;
    }
}

/**
 * 單例懶漢式二（2）
 * 線程安全（適用於多線程，優化效率）
 */
public class SingletonLazy3 {

    private static SingletonLazy3 INSTANCE;

    private SingletonLazy3() {}

    public static SingletonLazy3 getInstance() {
        if (INSTANCE == null) { // 不等於空直接返回，提高效率
            synchronized (SingletonLazy3.class) {
                if (INSTANCE == null) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new SingletonLazy3();
                }
            }
        }

        return INSTANCE;
    }
}

• 靜態內部類形式（適用於多線程）

　　  在內部類被加載和初始化時，才創建INSTANCE實例對象
　　  靜態內部類不會自動隨着外部類的加載和初始化而初始化，它是要單獨去加載和初始化的
　　  因為是在內部類加載和初始化時創建的，因此是線程安全的

/**
 * 單例懶漢式三
 * 靜態內部類（適用於多線程）
 * 在內部類被加載和初始化時，才創建INSTANCE實例對象
 * 靜態內部類不會自動隨着外部類的加載和初始化而初始化，它是要單獨去加載和初始化的
 * 因為是在內部類加載和初始化時，創建的，因此是線程安全的
 */
public class SingletonLazy4 {

    private SingletonLazy4() {}

    private static class Inner {
        private static final SingletonLazy4 INSTANCE = new SingletonLazy4();
    }

    public static SingletonLazy4 getInstance() {
        return Inner.INSTANCE;
    }
}

  

本文用於記錄Singleton的學習，方便以后回顧！學完的東西容易忘，以文章的形式記錄下來。歡迎大家學習和指出文章中的錯誤，謝謝！

示例代碼-碼雲