單例模式，你真的寫對了嗎？

看公司代碼的時候發現項目中單例模式應用挺多的，並且發現的兩處單例模式用的還是不同的方式實現的，那麼單例模式到底有幾種寫法呢？單例模式看似很簡單，但是實際寫起來卻問題多多

本文大綱

什麼是單例模式
餓漢式創建單例對象
懶漢式創建單例對象
單例模式的優缺點
單例模式的應用場景

什麼是單例模式

確保某個類只有一個實例，而且自行實例化並向整個系統提供這個實例，並且有兩種創建方式，一種是餓漢式創建，另外一種是懶漢式創建

餓漢式創建單例模式

餓漢式創建就是在類加載時就已創建好對象，而不是在需要時在創建對象

public class HungrySingleton {
    private static HungrySingleton hungrySingleton = new HungrySingleton();

    /**
     * 私有構造函數，不能被外部所訪問
     */
    private HungrySingleton() {}

    /**
     * 返回單例對象
     * */
    public static HungrySingleton getHungrySingleton() {
        return hungrySingleton;
    }
}

說明：

構造函數私有化，保證外部不能調用構造函數創建對象，創建對象的行爲只能由這個類決定
只能通過getHungrySingleton方法獲取對象
HungrySingleton對象已經創建完成【在類加載時創建】

缺點：

如果getHungrySingleton一直沒有被使用到，有點浪費資源

優點：

由ClassLoad保證線程安全

懶漢式創建單例模式

懶漢式創建就是在第一次需要該對象時在創建

存在錯誤的懶漢式創建單例對象
根據定義很容易在上面餓漢式的基礎上進行修改
```
public class LazySingleton {
    private static LazySingleton lazySingleton = null;

    /**
     * 構造函數私有化
     * */
    private LazySingleton() {
    }

    private static LazySingleton getLazySingleton() {
        if (lazySingleton == null) {
            return new LazySingleton();
        }

        return lazySingleton;
    }
}
```
說明：
- 構造函數私有化
- 當需要時【getLazySingleton方法調用時】才創建
  嗯，好像沒什麼問題，但是當有多個線程同時調用getLazySingleton方法時，此時剛好對象沒有初始化，兩個線程同時通過lazySingleton == null的校驗，將會創建兩個LazySingleton對象。必須搞點手段使getLazySingleton方法是線程安全的

synchronize或Lock
很容易想到使用synchronize或Lock對方法進行加鎖
使用synchronize：

public class LazySynchronizeSingleton {
    private static LazySynchronizeSingleton lazySynchronizeSingleton= null;

    /**
     * 構造函數私有化
     * */
    private LazySynchronizeSingleton() {
    }

    public synchronized static LazySynchronizeSingleton getLazySynchronizeSingleton() {
        if (lazySynchronizeSingleton == null) {
            lazySynchronizeSingleton = new LazySynchronizeSingleton();
        }

        return lazySynchronizeSingleton;
    }
}

使用Lock：

public class LazyLockSingleton {
    private static LazyLockSingleton lazyLockSingleton = null;

    /**
    * 鎖
    **/
    private static Lock lock = new ReentrantLock();

    /**
     * 構造函數私有化
     * */
    private LazyLockSingleton() {
    }

    public static LazyLockSingleton getLazyLockSingleton() {
        try {
            lock.lock();
            if (lazyLockSingleton == null) {
                lazyLockSingleton = new LazyLockSingleton();
            }
        } finally {
            lock.unlock();
        }

        return lazyLockSingleton;
    }
}

這兩種方式雖然保證了線程安全，但是性能較差，因爲線程不安全主要是由這段代碼引起的：

if (lazyLockSingleton == null) {
  lazyLockSingleton = new LazyLockSingleton();
}

給方法加鎖無論對象是否已經初始化都會造成線程阻塞。如果對象爲null的情況下才進行加鎖，對象不爲null的時候則不進行加鎖，那麼性能將會得到提升，雙重鎖檢查可以實現這個需求

雙重鎖檢查

在加鎖之前先判斷lazyDoubleCheckSingleton == null是否成立，如果不成立直接返回創建好的對象，成立在加鎖

public class LazyDoubleCheckSingleton {
    /**
     * 使用volatile進行修飾，禁止指令重排
     * */
    private static volatile LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;

    /**
     * 構造函數私有化
     * */
    private LazyDoubleCheckSingleton() {
    }

    public static LazyDoubleCheckSingleton getLazyDoubleCheckSingleton() {
        if (lazyDoubleCheckSingleton == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (lazyDoubleCheckSingleton == null) {
                    lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
                }
            }
        }

        return lazyDoubleCheckSingleton;
    }
}

說明：

爲什麼需要對lazyDoubleCheckSingleton添加volatile修飾符
因爲lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();不是原子性的，分爲三步：
- 爲lazyDoubleCheckSingleton分配內存
- 調用構造函數進行初始化
- 將lazyDoubleCheckSingleton對象指向分配的內存【執行完這步lazyDoubleCheckSingleton將不爲null】爲了提高程序的運行效率，編譯器會進行一個指令重排，步驟2和步驟三進行了重排，線程1先執行了步驟一和步驟三，執行完後，lazyDoubleCheckSingleton不爲null，此時線程2執行到if (lazyDoubleCheckSingleton == null)，線程2將可能直接返回未正確進行初始化的lazyDoubleCheckSingleton對象。出錯的原因主要是lazyDoubleCheckSingleton未正確初始化完成【寫】，但是其他線程已經讀取lazyDoubleCheckSingleton的值【讀】，使用volatile可以禁止指令重排序，通過內存屏障保證寫操作之前不會調用讀操作【執行if (lazyDoubleCheckSingleton == null)】

缺點：

爲了保證線程安全，代碼不夠優雅過於臃腫

靜態內部類

public class LazyStaticSingleton {
    /**
     * 靜態內部類
     * */
    private static class LazyStaticSingletonHolder {
        private static LazyStaticSingleton lazyStaticSingleton = new LazyStaticSingleton();
    }

    /**
     * 構造函數私有化
     * */
    private LazyStaticSingleton() {
    }

    public static LazyStaticSingleton getLazyStaticSingleton() {
        return LazyStaticSingletonHolder.lazyStaticSingleton;
    }
}

靜態內部類在調用時纔會進行初始化，因此是懶漢式的，LazyStaticSingleton lazyStaticSingleton = new LazyStaticSingleton();看似是餓漢式的，但是隻有調用getLazyStaticSingleton時纔會進行初始化，線程安全由ClassLoad保證，不用思考怎麼加鎖

前面幾種方式實現單例的方式雖然各有優缺點，但是基本實現了單例線程安全的要求。但是總有人看不慣單例模式勤儉節約的優點，對它進行攻擊。對它進行攻擊無非就是創建不只一個類，java中創建對象的方式有new、clone、序列化、反射。構造函數私有化不可能通過new創建對象、同時單例類沒有實現Cloneable接口無法通過clone方法創建對象，那剩下的攻擊只有反射攻擊和序列化攻擊了
反射攻擊：

public class ReflectAttackTest {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //靜態內部類
        LazyStaticSingleton lazyStaticSingleton = LazyStaticSingleton.getLazyStaticSingleton();
        //通過反射創建LazyStaticSingleton
        Constructor<LazyStaticSingleton> constructor = LazyStaticSingleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        LazyStaticSingleton lazyStaticSingleton1 = constructor.newInstance();
        //打印結果爲false，說明又創建了一個新對象
        System.out.println(lazyStaticSingleton == lazyStaticSingleton1);

        //synchronize
        LazySynchronizeSingleton lazySynchronizeSingleton = LazySynchronizeSingleton.getLazySynchronizeSingleton();
        Constructor<LazySynchronizeSingleton> lazySynchronizeSingletonConstructor = LazySynchronizeSingleton.class.getDeclaredConstructor();
        lazySynchronizeSingletonConstructor.setAccessible(true);
        LazySynchronizeSingleton lazySynchronizeSingleton1 = lazySynchronizeSingletonConstructor.newInstance();
        System.out.println(lazySynchronizeSingleton == lazySynchronizeSingleton1);

        //lock
        LazyLockSingleton lazyLockSingleton = LazyLockSingleton.getLazyLockSingleton();
        Constructor<LazyLockSingleton> lazyLockSingletonConstructor = LazyLockSingleton.class.getDeclaredConstructor();
        lazyLockSingletonConstructor.setAccessible(true);
        LazyLockSingleton lazyLockSingleton1 = lazyLockSingletonConstructor.newInstance();
        System.out.println(lazyLockSingleton == lazyLockSingleton1);

        //雙重鎖檢查
        LazyDoubleCheckSingleton lazyDoubleCheckSingleton = LazyDoubleCheckSingleton.getLazyDoubleCheckSingleton();
        Constructor<LazyDoubleCheckSingleton> lazyDoubleCheckSingletonConstructor = LazyDoubleCheckSingleton.class.getDeclaredConstructor();
        lazyDoubleCheckSingletonConstructor.setAccessible(true);
        LazyDoubleCheckSingleton lazyDoubleCheckSingleton1 = lazyDoubleCheckSingletonConstructor.newInstance();
        System.out.println(lazyDoubleCheckSingleton == lazyDoubleCheckSingleton1);
    }
}

都存在反射攻擊，都可以創建出一個新對象，打印結果都爲false。針對存在的反射攻擊根據網上提供的思路在搶救一下，搶救姿勢如下：

 private LazySynchronizeSingleton() {
      //flag爲線程間共享，進行加鎖控制
      synchronized (LazySynchronizeSingleton.class) {
          if (flag == false) {
              flag = !flag;
          } else {
              throw new RuntimeException("單例模式被攻擊");
          }
      }
  }

構造函數只能調用一次，調用第二次將拋出異常，通過flag來判斷構造函數是否已經被調用過一次了。但是我們仍可以通過反射修改flag的值：

//調用反射前將flag設置爲false
Field flagField = lazySynchronizeSingleton.getClass().getDeclaredField("flag");
flagField.setAccessible(true);
flagField.set(lazySynchronizeSingleton, false);

搶救失敗，你可能想通過final修飾禁止修改，但是反射可以先去除final，在加上final修改值，對於反射攻擊，無力迴天，只能選擇不適用存在反射攻擊的單例創建方式

反序列化攻擊：

public class SerializableAttackTest {
    public static void main(String[] args) {
        //懶漢式
        HungrySingleton hungrySingleton = HungrySingleton.getHungrySingleton();
        //序列化
        byte[] serialize = SerializationUtils.serialize(hungrySingleton);
        //反序列化
        HungrySingleton hungrySingleton1 = SerializationUtils.deserialize(serialize);
        System.out.println(hungrySingleton == hungrySingleton1);

        //雙重鎖
        LazyDoubleCheckSingleton lazyDoubleCheckSingleton = LazyDoubleCheckSingleton.getLazyDoubleCheckSingleton();
        byte[] serialize1 = SerializationUtils.serialize(lazyDoubleCheckSingleton);
        LazyDoubleCheckSingleton lazyDoubleCheckSingleton11 = SerializationUtils.deserialize(serialize1);
        System.out.println(lazyDoubleCheckSingleton == lazyDoubleCheckSingleton11);

        //lock
        LazyLockSingleton lazyLockSingleton = LazyLockSingleton.getLazyLockSingleton();
        byte[] serialize2 = SerializationUtils.serialize(lazyLockSingleton);
        LazyLockSingleton lazyLockSingleton1 = SerializationUtils.deserialize(serialize2);
        System.out.println(lazyLockSingleton == lazyLockSingleton1);

        //synchronie
        LazySynchronizeSingleton lazySynchronizeSingleton = LazySynchronizeSingleton.getLazySynchronizeSingleton();
        byte[] serialize3 = SerializationUtils.serialize(lazySynchronizeSingleton);
        LazySynchronizeSingleton lazySynchronizeSingleton1 = SerializationUtils.deserialize(serialize3);
        System.out.println(lazySynchronizeSingleton == lazySynchronizeSingleton1);

        //靜態內部類
        LazyStaticSingleton lazyStaticSingleton = LazyStaticSingleton.getLazyStaticSingleton();
        byte[] serialize4 = SerializationUtils.serialize(lazySynchronizeSingleton);
        LazyStaticSingleton lazyStaticSingleton1 = SerializationUtils.deserialize(serialize4);
        System.out.println(lazyStaticSingleton == lazyStaticSingleton1);

    }
}

打印結果都爲false，都存在反序列化攻擊
對於反序列化攻擊，還是有有效的搶救方式的，搶救姿勢如下：

private Object readResolve() {
    return lazySynchronizeSingleton;
}
複製代碼

添加readResolve方法並返回創建的單例對象，至於搶救的原理，可以通過跟進SerializationUtils.deserialize的代碼可知
上述實現單例對象的方式既要考慮線程安全、又要考慮攻擊，而通過枚舉創建單例對象完全不用擔心這些問題

枚舉

public enum EnumSingleton {
    INSTANCE;

    public static EnumSingleton getEnumSingleton() {
        return INSTANCE;
    }
}

代碼實現也相當優美，總共才8行代
實現原理：枚舉類的域(field)其實是相應的enum類型的一個實例對象
可以參考：implementing-singleton-with-an-enum-in-java
枚舉攻擊測試：

public class EnumAttackTest {
  public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
      EnumSingleton enumSingleton = EnumSingleton.getEnumSingleton();
      //序列化攻擊
      byte[] serialize4 = SerializationUtils.serialize(enumSingleton);
      EnumSingleton enumSingleton2 = SerializationUtils.deserialize(serialize4);
      System.out.println(enumSingleton == enumSingleton2);

      //反射攻擊
      Constructor<EnumSingleton> enumSingletonConstructor = EnumSingleton.class.getDeclaredConstructor();
      enumSingletonConstructor.setAccessible(true);
      EnumSingleton enumSingleton1 = enumSingletonConstructor.newInstance();
      System.out.println(enumSingleton == enumSingleton1);
  }
}

反射攻擊將會拋出異常，序列化攻擊對它無效，打印結果爲true，用枚舉創建單例對象真的是無懈可擊

單例模式的優點

只創建了一個實例，節省內存開銷
減少了系統的性能開銷，創建對象回收對象對性能都有一定的影響
避免對資源的多重佔用
在系統設置全局的訪問點，優化和共享資源優化

總結一下就是節約資源、提升性能

單例模式的缺點

不適用於變化的對象
單例模式中沒有抽象層，擴展有困難
與單一原則衝突。一個類應該只實現一個邏輯，而不關心它是否單例，是不是單例應該由業務決定

單例模式的應用場景

Spring IOC默認使用單例模式創建bean
創建對象需要消耗的資源過多時
需要定義大量的靜態常量和靜態方法的環境，比如工具類【感覺是最常見應用場景】

小結

總共介紹了六種正確創建單例對象的方式，推薦使用餓漢式創建單例對象的方式，如果對資源使用有要求，則推薦使用靜態內部類【注意反序列化攻擊】，其他方式在保證線程安全的同時對性能將會有影響。枚舉類其實是非常不錯的，線程安全、不存在反射攻擊和反序列化攻擊，但是感覺這種創建單例方式應用較少，公司代碼中使用的是雙重鎖檢查和靜態內部類【存在反序列化攻擊】創建單例方式，甚至之前出去面試時面試官讓寫一個單例，我使用的是枚舉方式，面試官都不知道有這種方式

附：完整例子代碼+測試代碼

單例模式，你真的寫對了嗎？

本文大綱

什麼是單例模式

餓漢式創建單例模式

懶漢式創建單例模式

單例模式的優點

單例模式的缺點

單例模式的應用場景

小結

顯示IP歸屬地原理&Java實現IP歸屬地顯示功能

SpringBoot版微信支付實戰教程（視頻 +源碼+筆記）

MyBatis-Plus 條件構造器常用方法使用（相等判斷、範圍判斷、模糊匹配、非空判斷、in判斷、分組、排序、條件判斷、邏輯判斷、存在判斷、查詢字段）

Android App桌面長按菜單展示快捷操作

SpringBoot -開發中常用約束註解

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

linux以太網驅動總結