@TOC

設計模式介紹

1）設計模式是程序員在面對同類軟件工程設計問題所總結出來的有用的經驗，模式不是代碼，而是某類問題的通用解決方案，設計模式（Design pattern）代碼了最佳的實踐。這些解決方案是眾多軟件開發(fā)人員經過相當長的一段時間的試驗和錯誤總結出來的。
2）設計模式的本質提高軟件的維護性、通用性和擴展性，并降低軟件的復雜度。
3）《設計模式》是經典的書，作者是Erich Gamma\Richard Helm\ Ralph Johnson和John Vlissides Design（俗稱“四人組GOF”）
4）設計模式并不局限于某種語言，Java、PHP、C++都有設計模式。

設計模式類型

設計模式分為三種類型，共23種
1）創(chuàng)建型模式 ：單例模式、抽象工廠模式、原型模式、建造者模式、工廠模式。
2）結構型模式 ：適配器模式、橋接模式、裝飾模式、組合模式、外觀模式、享元模式、代理模式。
3）行為型模式 ：模板方法模式、命令模式、訪問者模式、迭代器模式、觀察者模式、中介者模式、備忘錄模式、解釋器模式（Interpreter模式）、狀態(tài)模式、策略模式、職責鏈模式（責任鏈模式）。

單例設計模式介紹

所謂類的單例設計模式，就是采取一定的方法保證了在整個的軟件系統(tǒng)中，對某個類只能存在一個對象實例，并且該類只提供一個取得其對象實例的方法。
比如Hibernate的SessionFactory，它充當數(shù)據存儲源的代理，并負責創(chuàng)建Session對象。SessionFactory并不是輕量級的，一般情況下，一個項目通常只需要一個SessionFactory就夠，這時就會使用到單例模式。

• 單例設計模式八種方式
  1）餓漢式（靜態(tài)常量）
  2）餓漢式（靜態(tài)代碼塊）
  3）懶漢式（線程不安全）
  4）懶漢式（線程安全，同步方法）
  5）懶漢式（線程安全，同步代碼塊）
  6）雙重檢查
  7）靜態(tài)內部類
  8）枚舉

餓漢式（靜態(tài)常量）

步驟如下 ：
1）構造器私有化（防止 new 對象）
2）類的內部創(chuàng)建對象
3）向外暴露一個靜態(tài)的公共方法。
4）代碼實現(xiàn)

package com.example.demo.singleton.type1;

public class SingletonTest01 {
    public static void main(String[] args) {
        // 測試
        Singleton instanceSingleton = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instanceSingleton == instance2);
    }
}

/**
 * 餓漢式（靜態(tài)變量）
 * @author Administrator
 *
 */
class Singleton {
    
    /**
     * 1. 構造器私有化，外不能new
     */
    private Singleton() {
        
    }
    /**
     * 2. 本類內部創(chuàng)建對象實例
     */
    private final static Singleton instance = new Singleton();
    
    /**
     * 3. 提供一個公有的靜態(tài)方法，返回實例對象
     * @return
     */
    public static Singleton getInstance() {
        return instance;
    }
}

優(yōu)缺點說明 ：
1）優(yōu)點 : 這種寫法比較簡單，就是在類裝載的時候完成實例化。避免了線程同步問題。
2）缺點 ：在類裝載的時候就完成實例化，沒有達到Lazy Loading的效果。如果從始至終從未使用過這個實例，則會造成內存的浪費。
3）這種方式基于classLoader機制避免了多線程的同步問題，不過，instance在類裝載時就實例化，在單例模式中大多是都是調用getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式（或者其他的靜態(tài)方法）導致類裝載，這時候初始化instance就沒有達到lazy loading的效果
4）結論 ：這種單例模式可用，可能造成內存浪費。

餓漢式（靜態(tài)代碼塊）

package com.example.demo.singleton.type1;

public class SingletonTest02 {
    public static void main(String[] args) {
        // 測試
        Singleton instanceSingleton = Singleton.getSingleton();
        Singleton instance2 = Singleton.getSingleton();
        System.out.println(instanceSingleton == instance2);
        System.out.println("instance.hashCode = " + instanceSingleton.hashCode());
        System.out.println("instance2.hashCode = " + instance2.hashCode());
    }
}

/**
 * 餓漢式（靜態(tài)常量）
 * @author Administrator
 *
 */
class Singleton {
    
    /**
     * 1. 構造器私有化，外部不能new
     */
    private Singleton() {
        
    }
    
    /**
     * 2. 本類內部創(chuàng)建對象實例
     */
    private static Singleton instance;
    
    static {
        // 在靜態(tài)代碼塊中，創(chuàng)建單例對象
        instance = new Singleton();
    }
    
    /**
     * 3. 提供一個公有的靜態(tài)方法，返回實例對象
     * @return
     */
    public static Singleton getSingleton() {
        return instance;
    }
}

優(yōu)缺點說明 ：
1）這種方式和上面的方式其實類似，只不過將類實例化的過程放在了靜態(tài)代碼塊中，也是在類裝載的時候，就執(zhí)行靜態(tài)代碼塊中的代碼，初始化類的實例。優(yōu)缺點和上面是一樣的。
2）結論 ：這種單例模式可用，但是可能造成內存浪費。

懶漢式（線程不安全）

package com.example.demo.singleton.type1;

public class SingletonTest3 {
    public static void main(String[] args) {
        System.out.println("懶漢式1 ， 線程不安全");
        Singleton instanceSingleton = Singleton.getInstance();
        Singleton iSingleton = Singleton.getInstance();
        System.out.println(instanceSingleton == iSingleton);
        System.out.println("instance.hashCode = " + instanceSingleton.hashCode());
        System.out.println("instance2.hashCode = " + iSingleton.hashCode());
    }
}

class Singleton {
    private static Singleton instanceSingleton;
    
    private Singleton() {}
    
    /**
     * 提供一個靜態(tài)的公有方法，當使用到該方法時，才去創(chuàng)建 instance
     * 即懶漢式
     * @return
     */
    public static Singleton getInstance() {
        if (instanceSingleton == null) {
            instanceSingleton = new Singleton();
        }
        return instanceSingleton;
    }
}

優(yōu)缺點說明 ：
1）起到了Lazy Loading的效果，但是只能在單線程下使用。
2）如果在多線程下，一個線程進入了if(singleton == null)判定語句塊，還未來得及往下執(zhí)行，另一個線程也通過了這個判定語句，這時便會產生多個實例。所以在多線程環(huán)境下不可使用這種方式
3）結論 ： 在實際開發(fā)中，不要使用這種方式。

懶漢式（線程安全，同步方法）

package com.example.demo.singleton.type1;

public class SingletonTest4 {
    public static void main(String[] args) {
        System.out.println("懶漢式1 ， 線程不安全");
        Singleton instanceSingleton = Singleton.getInstance();
        Singleton iSingleton = Singleton.getInstance();
        System.out.println(instanceSingleton == iSingleton);
        System.out.println("instance.hashCode = " + instanceSingleton.hashCode());
        System.out.println("instance2.hashCode = " + iSingleton.hashCode());
    }
}

class Singleton {
    private static Singleton instanceSingleton;
    
    private Singleton() {}
    
    /**
     * 提供一個靜態(tài)的公有方法，加入同步處理的代碼，解決線程安全問題
     * 即懶漢式
     * @return
     */
    public static synchronized Singleton getInstance() {
        if (instanceSingleton == null) {
            instanceSingleton = new Singleton();
        }
        return instanceSingleton;
    }
}

優(yōu)缺點說明 ：
1）解決了線程不安全的問題
2）效率太低了，每個線程在想獲得類的實例時候，執(zhí)行getInstance()方法都要進行同步。而其實這個方法只執(zhí)行一次實例化代碼就夠了，后面的想獲得該類實例，直接returne就行了。方法進行同步效率太低
3）結論 ： 在實際開發(fā)中，不推薦使用這種方式

懶漢式（線程安全，同步代碼塊）

package com.example.demo.singleton.type1;

public class SingletonTest4 {
    public static void main(String[] args) {
        System.out.println("懶漢式1 ， 線程不安全");
        Singleton instanceSingleton = Singleton.getInstance();
        Singleton iSingleton = Singleton.getInstance();
        System.out.println(instanceSingleton == iSingleton);
        System.out.println("instance.hashCode = " + instanceSingleton.hashCode());
        System.out.println("instance2.hashCode = " + iSingleton.hashCode());
    }
}

class Singleton {
    private static Singleton instanceSingleton;
    
    private Singleton() {}
    
    /**
     * 即懶漢式
     * @return
     */
    public static Singleton getInstance() {
        if (instanceSingleton == null) {
            synchronized (Singleton.class) {
                instanceSingleton = new Singleton();
            }
        }
        return instanceSingleton;
    }
}

優(yōu)缺點說明 ：
1）這種方式，本意是想對第四種實現(xiàn)方式的改進，因為前面同步方法效率太低，改為同步產生實例化的代碼塊
2）但是這種同步并不能起到線程同步的作用。跟第3種實現(xiàn)方式遇到的情況一致，假如一個線程進入了if（singleton == null）判定語句塊，還未來得及往下執(zhí)行，另一個線程也通過了這個判定語句，這時便會產生多個實例
3）結論 ：在實際開發(fā)中，不能使用這種方式

雙重檢查

package com.example.demo.singleton.type1;

public class SingletonTest6 {
    public static void main(String[] args) {
        System.out.println("靜態(tài)內部類");
        Singleton instanceSingleton = Singleton.getInstance();
        Singleton iSingleton = Singleton.getInstance();
        System.out.println(instanceSingleton == iSingleton);
        System.out.println("instance.hashCode = " + instanceSingleton.hashCode());
        System.out.println("instance2.hashCode = " + iSingleton.hashCode());
    }
}

class Singleton {
    private static volatile Singleton instanceSingleton;
    
    private Singleton() {}
    
    /**
     * 提供一個靜態(tài)的公有方法，加入雙重檢查代碼，解決線程安全問題，同時解決懶加載問題,同時保證效率
     * @return
     */
    public static synchronized Singleton getInstance() {
        if (instanceSingleton == null) {
            synchronized (Singleton.class) {
                if (instanceSingleton == null) {
                    instanceSingleton = new Singleton();
                }
            }
        }
        return instanceSingleton;
    }
}

優(yōu)缺點說明 ：
1）Double-Check概念是多線程開發(fā)中常使用到的，如代碼中所示，我們進行了兩次if（singleton == null）檢查，這樣就可以保證線程安全了。
2）這樣，實例化代碼只用執(zhí)行一次，后面再次訪問時，判定if（singleton == null）,直接return實例化對象，也避免的反復進行方法同步。
3）線程安全；延遲加載；效率較高
4）結論 ：在實際開發(fā)中，推薦使用這種單例設計模式

靜態(tài)內部類

package com.example.demo.singleton.type1;

public class SingletonTest6 {
    public static void main(String[] args) {
        System.out.println("靜態(tài)內部類");
        Singleton instanceSingleton = Singleton.getInstance();
        Singleton iSingleton = Singleton.getInstance();
        System.out.println(instanceSingleton == iSingleton);
        System.out.println("instance.hashCode = " + instanceSingleton.hashCode());
        System.out.println("instance2.hashCode = " + iSingleton.hashCode());
    }
}
/**
 * 靜態(tài)內部類完成
 * @author Administrator
 *
 */
class Singleton {
    
    /**
     * 構造器私有化
     */
    private Singleton() {}
    
    /**
     * 寫一個靜態(tài)內部類，該類中有一個靜態(tài)屬性 Singleton
     * @author Administrator
     *
     */
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    /**
     * 提供一個靜態(tài)的公有方法，直接返回SingletonInstance.INSTANCE
     * @return
     */
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

優(yōu)缺點說明 ：
1）這種方式采用了類裝載的機制來保證初始化實例時只有一個線程。
2）靜態(tài)內部類方式在Singleton類被裝載時并不會立即實例化，而是在需要實例化時，調用getInstance方法，才會裝載SingletonInstance類，從而完成Singleton的實例化。
3）類的靜態(tài)屬性只會在第一次加載類的時候初始化，所以在這里，JVM幫助我們保證了線程的安全性，在類進行初始化時，別的線程是無法進入的。
4）優(yōu)點 ：避免了線程不安全，利用靜態(tài)內部類特點實現(xiàn)延遲加載，效率高
5）結論 ：推薦使用

枚舉

package com.example.demo.singleton.type1;

public class SingletonTest7 {
    public static void main(String[] args) {
        System.out.println("枚舉");
        Singleton instanceSingleton = Singleton.INSTANCE;
        Singleton iSingleton = Singleton.INSTANCE;
        System.out.println(instanceSingleton == iSingleton);
        System.out.println("instance.hashCode = " + instanceSingleton.hashCode());
        System.out.println("instance2.hashCode = " + iSingleton.hashCode());
        instanceSingleton.sayOk();
    }
}

/**
 * 使用枚舉，可以實現(xiàn)單例
 * @author Administrator
 *
 */
enum Singleton {
    INSTANCE;// 屬性
    public void sayOk() {
        System.out.println("ok~");
    }
}

優(yōu)缺點說明 ：
1）這借助JDK1.5中添加的枚舉來實現(xiàn)單例模式。不僅能避免多線程同步問題，而且還能防止反序列化重新創(chuàng)建新的對象。
2）這種方式是Effective Java作者Josh Bloch提倡的方式
3）結論 ： 推薦使用

• 單例模式在JDK應用的源碼分析
  單例模式在JDK應用的源碼分析
  1）我們JDK中，java.lang.Runtime就是經典的單例模式
  2）代碼分析 + Debug源碼 + 代碼說明

  
  
  在這里插入圖片描述

單例模式注意事項和細節(jié)說明

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