最簡單的設計模式不會還有人不會吧！

時間 2021-01-02

標籤 java 程序員數據庫編程設計模式安全 session 多線程框架 jvm 欄目 Java 简体版

原文原文鏈接

前言

掌握設計模式的層次java

剛開始學編程不久，據說過什麼是設計模式
由很長時間的編程經驗，本身寫了不少代碼，其中用到了設計模式，可是本身殊不知道
學習過了設計模式，發現本身已經在使用了，而且發現了一些新的模式挺好用的
閱讀了不少別人寫的源碼和框架，在其中看到別人設計模式，而且可以領會設計模式的精妙和帶來的好處。
代碼寫着寫着，字節都沒有意識到使用了設計模式，而且熟練的寫了出來。

設計模式介紹程序員

設計模式是程序員再面對同類軟件工程設計問題所總結出來的有用的經驗，模式不是代碼，而是某類問題的通用解決方案，設計模式(Design pattern)表明了最佳的實踐。這些解決方案是衆多軟件開發人員通過至關長的時間的試驗和錯誤總結出來的。
設計模式的本質提升軟件的維護性，通用性和擴展性，並下降軟件的複雜度。

設計模式分爲三種類型，共23種數據庫

建立型模式：單例模式，抽象工廠模式，原型模式，建造者模式，工程模式。編程
結構型模式：適配器模式，橋接模式，裝飾模式，組合模式，外觀模式，享元模式，代理模式設計模式
行爲型模式：模塊方法模式，命令模式，訪問者模式，迭代模式，觀察者模式，中介者模式，備忘錄模式，解釋器模式(Interpreter模式)，狀態模式，策略模式，職責鏈模式(責任鏈模式)安全

注意:不一樣的書籍上對分類和名稱略有差異。session

單例模式

單例模式介紹多線程

所謂類的單例設計模式，就是採起必定的方法保證再整個的軟件系統中，對某個類只能存在一個對象實例，而且該類只提供了一個取得對象實例的方法(靜態方法)。框架

好比Hibernate的SessionFactory，他充當數據存儲源的代理，並負責建立Session對象。SessionFactory並非輕量級的，通常狀況下，一個項目一般只須要一個SessionFactoury就夠，這是就會用到單例模式。jvm
單例設計模式有八種寫法
1. 餓漢式(靜態常量)
2. 餓漢式(靜態代碼塊)
3. 懶漢式(線程不安全)
4. 懶漢式(線程安全，同步方法)
5. 懶漢式(線程安全，同步代碼塊)
6. 雙重檢查
7. 靜態內部類
8. 枚舉

餓漢式(靜態常量)

步驟以下:

構造器私有化(防止 new)
類的內部建立對象
向外暴露一個靜態的公共方法。gentInstance

代碼實現

public class SingletonTest1 {
   public static void main(String[] args) {
       //測試
       Singleton instance = Singleton.getInstance();
       Singleton instance1 = Singleton.getInstance();
       System.out.println(instance == instance1);//true
       System.out.println("instance.hashCode=" + instance.hashCode());//1163157884
       System.out.println("instance1.hashCode=" + instance1.hashCode());//1163157884
   }
}

//餓漢式(靜態變量)
class Singleton {
   //1. 私有化構造器，外部不能能new
   private Singleton() {}
   //2. 在本類內部建立對象實例
   private final static Singleton instance = new Singleton();
   //3. 提供一個共有的靜態方法，返回實例對象
   public static Singleton getInstance() {
       return instance;
   }
}

優缺點說明
1. 優勢；這種寫法比較簡單，就是再類裝載的時候就完成實例化。避免了線程同步問題。
2. 缺點；再類裝載的時候就完成實例化，沒有達到Lazy Loading(懶加載)的效果。若是從始至終從未使用這個實例，則會形成內存的浪費。
3. 這種方法基於classloder機制避免了多線程的同步問題，不過，instance再類裝載時就實例化，再單例模式種大多數都是調用getInstance方法，可是致使類裝載的緣由有不少種，所以不能肯定其餘的方式(或者其餘的靜態方法)致使類裝載，這時候初始化instance就沒有達到lazy loading的效果
4. 結論；這種單例模式可用，可能形成內存浪費。
餓漢式(靜態代碼塊)

代碼

public class SingletonTest2 {
  public static void main(String[] args) {
      //測試
      Singleton instance = Singleton.getInstance();
      Singleton instance1 = Singleton.getInstance();
      System.out.println(instance == instance1);//true
      System.out.println("instance.hashCode=" + instance.hashCode());//1163157884
      System.out.println("instance1.hashCode=" + instance1.hashCode());//1163157884
  }
}

//餓漢式(靜態變量)
class Singleton {
  //1. 私有化構造器，外部不能能new
  private Singleton() { }
  //2. 在本類內部建立對象實例
  private static Singleton instance;
  //在靜態代碼塊中，建立對象
  static { instance = new Singleton(); }
  //3. 提供一個共有的靜態方法，返回實例對象
  public static Singleton getInstance() {
      return instance;
  }
}

優缺點說明
1. 這種方式和上面的方式其實相似，只不過將類實例的過程放在了靜態代碼塊中，也是再類裝載的時候，就執行靜態代碼塊中的代碼，初始化類的實例。優缺點和上面是同樣的。
2. 結論；這種單例模式可用，可是可能形成內存浪費。
懶漢式(線程不安全)

代碼

public class SingletonTest03 {
  public static void main(String[] args) {
      //測試
      System.out.println("懶漢式1，線程不安全");
      Singleton instance = Singleton.getInstance();
      Singleton instance1 = Singleton.getInstance();
      System.out.println(instance == instance1);//true
      System.out.println("instance.hashCode=" + instance.hashCode());//1163157884
      System.out.println("instance1.hashCode=" + instance1.hashCode());//1163157884
  }
}

class Singleton {
  private static Singleton instance;
  public Singleton() { }
  //提供一個靜態的共有方法，當使用該方法時，纔去建立instance
  //即懶漢式
  public static Singleton getInstance() {
      if (instance == null) {
          instance = new Singleton();
      }
      return instance;
  }
}

優勢說明

起到Lazy Loading的效果，可是隻能再單線程下使用。
若是再多線程下，一個線程進入if(singlenton == null) 判斷語句塊，還將來得及往下執行，另外一個線程也經過這個判斷語句，這是便會差生多個實例。因此再多線程環境下不可以使用這種方式。
結論：再實際開發中，不要使用這種方式。

懶漢式(線程安全，同步方法)

代碼

class Singleton{
  private static Singleton singlenton;
  private Singleton(){}
  //加入了同步代碼，解決線程不安全問題
  public static synchronized Singlenton getInstance(){
      if(singleton==null){
          singleton=new Singleton();
      }
      return singleton;
  }
}

優缺點說明
1. 解決了線程不安全的問題
2. 效率過低了，每一個線程在想得到類的實例時候，執行getInstance()方法都要進行同步。而其實這個方式執行一次實例化代碼就夠了，後面的想得到該類實例直接return就好了。方法進行同步效率過低
3. 結論；在實際開發中，不推薦使用這種方式。
懶漢式(線程安全，同步代碼塊)

代碼

class Singleton{
  private static Singleton singleton;
  private Singleton(){}
  public static Singleton getInstance(){
      if(singleton==null){
          //同代碼塊 
          synchronized (Singleton.class){
              singleton=new Singleton();
          }
          return singleton;
      }
  }
}

優缺點說明
1. 這種方式，本意是相對四種方法的改進，由於前面同步方法效率過低，改成同步生產實例的代碼塊。
2. <font color="red">可是這種同步並不能起到線程同步的做用</font>。跟第三種實現方式遇到的情形一致，加入一個線程進入了if(singleton==null)判斷語句塊，還將來得及往下執行，另一個線程也經過了這個判斷語句，這時便會產生多個實例。
3. 結論：在實際開發中，不能使用這種方式。
雙重檢查

代碼演示

class Singleton{
  //volatile把它認爲是一個輕量級的synchronized
  private static volatile  Singleton singleton;
  private Singleton(){}
  public static Singleton getInstance(){
    if(singleton==null){
          //保證只有一個線程在這裏執行，當下一個線程進來的時候，
          //上一個線程已經建立完了singleton已經不等於null了，就不會建立了
          //提供一個靜態的共有方法，加入雙重檢查代碼，解決線程安全問題，同時解決懶加載問題
          //同時保證了效率，推薦使用    
          synchronized(Singleton.class){
              if(singleton==null){
                  singleton=new Singleton();
              }
          }
      }
      return singleton;
  }
}

優缺點說明
1. Double-「Check概念是多線程開發中常使用的，若是代碼中所示，咱們進行了兩次if(singleton==null)檢查，這樣就能夠保證線程安全了。
2. 這樣，實例化代碼只用執行一次，後面再次訪問時，判斷if(singleton==null)，直接return實例化對象，也避免的反覆進行方法同步。
3. 線程安全；延遲加載；效率較高
4. 結論；在實際開發中，推薦使用這種單例設計模式。
靜態內部類

代碼演示

//當外部類裝載的時候靜態內部類不會被裝載的
//當咱們調用靜態方法時靜態內部類的時候只會裝載一次，並且裝載的時候線程是安全的。
public class SingletonTest07 {
  public static void main(String[] args) {
      Singleton instance = Singleton.getInstance();
      Singleton instance1 = Singleton.getInstance();
      System.out.println(instance == instance1);//true
      System.out.println("instance.hashCode=" + instance.hashCode());//instance1.hashCode=1163157884
      System.out.println("instance1.hashCode=" + instance1.hashCode());//instance1.hashCode=1163157884
  }
}
//靜態內部類完成，推薦使用
class Singleton {
  //構造器私有化
  private Singleton() { }
  //寫靜態內部類，該類有一個靜態屬性
  private static class SingletonInstance {
      private static final Singleton INSTANCE = new Singleton();
  }
  //提供一個靜態的共有方法，直接返回SingletonInstance.INSTANCE
  public static Singleton getInstance() {
      return SingletonInstance.INSTANCE;
  }
}

優缺點說明
1. 這種方式採用了類裝載的機制來保證初始化實例時只有一個線程。
2. 靜態內部類方式在Singleton類被裝載時並不會當即實例化，而是在須要實例化時調用getInstance方法，纔會裝載Singleton Instance類，從而完成Singleton的實例化。
3. 類的靜態屬性只會加載類的時候初始化，因此在這裏，jvm幫助咱們保證了線程的安全性，再類進行初始化時，別的線程是沒法進入的。
4. 優勢；避免了線程不安全，利用靜態內部類特色實現延遲加載，效率高
5. 結論；推薦使用。
枚舉

代碼實例

public class SingletonTest8 {
  public static void main(String[] args) {
      Singleton instance = Singleton.INSTANCE;
      Singleton instance2 = Singleton.INSTANCE;
      System.out.println(instance == instance2);//true
      System.out.println(instance.hashCode());//1163157884
      System.out.println(instance2.hashCode());//1163157884
      instance.sayOK();
  }
}
//使用枚舉能夠實現單例，推薦使用
enum Singleton {
  INSTANCE;
  public void sayOK() {
      System.out.println("ok~");}
}

優缺點說明
1. 這藉助jdk1.5中添加的枚舉來實現單例模式。不只能避免多線程同步問題，並且還能防止反序列化從新建立新的對象。
2. 這種方式式Effective java做者 josh bloch 提倡的方式
3. 結論；推薦使用

單例模式在jdk應用的源碼分析

咱們jdk中 java.lang.Runtime 就是經典的單例模式
代碼分析+Ddbug源碼+代碼說明

//單例設計模式的懶漢式
public class Runtime {
  private static Runtime currentRuntime = new Runtime();
      public static Runtime getRuntime() {
      return currentRuntime;
  }
  private Runtime() {}

單例模式注意事項和細節說明

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