圖解Java設計模式之單例設計模式
- 設計模式介紹
- 設計模式型別
- 單例設計模式介紹
- 餓漢式（靜態常量）
- 餓漢式（靜態代碼塊）
- 懶漢式（執行緒不安全）
- 懶漢式（執行緒安全，同步方法）
- 懶漢式（執行緒安全，同步代碼塊）
- 雙重檢查
- 靜態內部類
- 列舉
- 單例模式注意事項和細節說明
設計模式介紹
1）設計模式是程式員在面對同類軟體工程設計問題所總結出來的有用的經驗，模式不是代碼，而是某類問題的通用解決方案，設計模式（Design pattern）代碼了最佳的實踐，這些解決方案是眾多軟體開發人員經過相當長的一段時間的試驗和錯誤總結出來的，
2）設計模式的本質提高軟體的維護性、通用性和擴展性，并降低軟體的復雜度，
3）《設計模式》是經典的書，作者是Erich Gamma\Richard Helm\ Ralph Johnson和John Vlissides Design（俗稱“四人組GOF”）
4）設計模式并不局限于某種語言，Java、PHP、C++都有設計模式，
設計模式型別
設計模式分為三種型別，共23種
1）創建型模式 ：單例模式、抽象工廠模式、原型模式、建造者模式、工廠模式，
2）結構型模式 ：配接器模式、橋接模式、裝飾模式、組合模式、外觀模式、享元模式、代理模式，
3）行為型模式 ：模板方法模式、命令模式、訪問者模式、迭代器模式、觀察者模式、中介者模式、備忘錄模式、解釋器模式（Interpreter模式）、狀態模式、策略模式、職責鏈模式（責任鏈模式），
單例設計模式介紹
所謂類的單例設計模式，就是采取一定的方法保證了在整個的軟體系統中，對某個類只能存在一個物件實體，并且該類只提供一個取得其物件實體的方法，
比如Hibernate的SessionFactory，它充當資料存盤源的代理，并負責創建Session物件，SessionFactory并不是輕量級的，一般情況下，一個專案通常只需要一個SessionFactory就夠，這時就會使用到單例模式，
- 單例設計模式八種方式
1）餓漢式（靜態常量）
2）餓漢式（靜態代碼塊）
3）懶漢式（執行緒不安全）
4）懶漢式（執行緒安全，同步方法）
5）懶漢式（執行緒安全，同步代碼塊）
6）雙重檢查
7）靜態內部類
8）列舉
餓漢式（靜態常量）
步驟如下 ：
1）構造器私有化（防止 new 物件）
2）類的內部創建物件
3）向外暴露一個靜態的公共方法，
4）代碼實作
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);
}
}
/**
* 餓漢式（靜態變數）
* @author Administrator
*
*/
class Singleton {
/**
* 1. 構造器私有化，外不能new
*/
private Singleton() {
}
/**
* 2. 本類內部創建物件實體
*/
private final static Singleton instance = new Singleton();
/**
* 3. 提供一個公有的靜態方法，回傳實體物件
* @return
*/
public static Singleton getInstance() {
return instance;
}
}
優缺點說明 ：
1）優點 : 這種寫法比較簡單，就是在類裝載的時候完成實體化，避免了執行緒同步問題，
2）缺點 ：在類裝載的時候就完成實體化，沒有達到Lazy Loading的效果，如果從始至終從未使用過這個實體，則會造成記憶體的浪費，
3）這種方式基于classLoader機制避免了多執行緒的同步問題，不過，instance在類裝載時就實體化，在單例模式中大多是都是呼叫getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式（或者其他的靜態方法）導致類裝載，這時候初始化instance就沒有達到lazy loading的效果
4）結論 ：這種單例模式可用，可能造成記憶體浪費，
餓漢式（靜態代碼塊）
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());
}
}
/**
* 餓漢式（靜態常量）
* @author Administrator
*
*/
class Singleton {
/**
* 1. 構造器私有化，外部不能new
*/
private Singleton() {
}
/**
* 2. 本類內部創建物件實體
*/
private static Singleton instance;
static {
// 在靜態代碼塊中，創建單例物件
instance = new Singleton();
}
/**
* 3. 提供一個公有的靜態方法，回傳實體物件
* @return
*/
public static Singleton getSingleton() {
return instance;
}
}
優缺點說明 ：
1）這種方式和上面的方式其實類似，只不過將類實體化的程序放在了靜態代碼塊中，也是在類裝載的時候，就執行靜態代碼塊中的代碼，初始化類的實體，優缺點和上面是一樣的，
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() {}
/**
* 提供一個靜態的公有方法，當使用到該方法時，才去創建 instance
* 即懶漢式
* @return
*/
public static Singleton getInstance() {
if (instanceSingleton == null) {
instanceSingleton = new Singleton();
}
return instanceSingleton;
}
}
優缺點說明 ：
1）起到了Lazy Loading的效果，但是只能在單執行緒下使用，
2）如果在多執行緒下，一個執行緒進入了if(singleton == null)判定陳述句塊，還未來得及往下執行，另一個執行緒也通過了這個判定陳述句，這時便會產生多個實體，所以在多執行緒環境下不可使用這種方式
3）結論 ： 在實際開發中，不要使用這種方式，
懶漢式（執行緒安全，同步方法）
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 synchronized Singleton getInstance() {
if (instanceSingleton == null) {
instanceSingleton = new Singleton();
}
return instanceSingleton;
}
}
優缺點說明 ：
1）解決了執行緒不安全的問題
2）效率太低了，每個執行緒在想獲得類的實體時候，執行getInstance()方法都要進行同步，而其實這個方法只執行一次實體化代碼就夠了，后面的想獲得該類實體，直接returne就行了，方法進行同步效率太低
3）結論 ： 在實際開發中，不推薦使用這種方式
懶漢式（執行緒安全，同步代碼塊）
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;
}
}
優缺點說明 ：
1）這種方式，本意是想對第四種實作方式的改進，因為前面同步方法效率太低，改為同步產生實體化的代碼塊
2）但是這種同步并不能起到執行緒同步的作用，跟第3種實作方式遇到的情況一致，假如一個執行緒進入了if（singleton == null）判定陳述句塊，還未來得及往下執行，另一個執行緒也通過了這個判定陳述句，這時便會產生多個實體
3）結論 ：在實際開發中，不能使用這種方式
雙重檢查
package com.example.demo.singleton.type1;
public class SingletonTest6 {
public static void main(String[] args) {
System.out.println("靜態內部類");
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() {}
/**
* 提供一個靜態的公有方法，加入雙重檢查代碼，解決執行緒安全問題，同時解決懶加載問題,同時保證效率
* @return
*/
public static synchronized Singleton getInstance() {
if (instanceSingleton == null) {
synchronized (Singleton.class) {
if (instanceSingleton == null) {
instanceSingleton = new Singleton();
}
}
}
return instanceSingleton;
}
}
優缺點說明 ：
1）Double-Check概念是多執行緒開發中常使用到的，如代碼中所示，我們進行了兩次if（singleton == null）檢查，這樣就可以保證執行緒安全了，
2）這樣，實體化代碼只用執行一次，后面再次訪問時，判定if（singleton == null）,直接return實體化物件，也避免的反復進行方法同步，
3）執行緒安全；延遲加載；效率較高
4）結論 ：在實際開發中，推薦使用這種單例設計模式
靜態內部類
package com.example.demo.singleton.type1;
public class SingletonTest6 {
public static void main(String[] args) {
System.out.println("靜態內部類");
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());
}
}
/**
* 靜態內部類完成
* @author Administrator
*
*/
class Singleton {
/**
* 構造器私有化
*/
private Singleton() {}
/**
* 寫一個靜態內部類，該類中有一個靜態屬性 Singleton
* @author Administrator
*
*/
private static class SingletonInstance {
private static final Singleton INSTANCE = new Singleton();
}
/**
* 提供一個靜態的公有方法，直接回傳SingletonInstance.INSTANCE
* @return
*/
public static synchronized Singleton getInstance() {
return SingletonInstance.INSTANCE;
}
}
優缺點說明 ：
1）這種方式采用了類裝載的機制來保證初始化實體時只有一個執行緒，
2）靜態內部類方式在Singleton類被裝載時并不會立即實體化，而是在需要實體化時，呼叫getInstance方法，才會裝載SingletonInstance類，從而完成Singleton的實體化，
3）類的靜態屬性只會在第一次加載類的時候初始化，所以在這里，JVM幫助我們保證了執行緒的安全性，在類進行初始化時，別的執行緒是無法進入的，
4）優點 ：避免了執行緒不安全，利用靜態內部類特點實作延遲加載，效率高
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();
}
}
/**
* 使用列舉，可以實作單例
* @author Administrator
*
*/
enum Singleton {
INSTANCE;// 屬性
public void sayOk() {
System.out.println("ok~");
}
}
優缺點說明 ：
1）這借助JDK1.5中添加的列舉來實作單例模式，不僅能避免多執行緒同步問題，而且還能防止反序列化重新創建新的物件，
2）這種方式是Effective Java作者Josh Bloch提倡的方式
3）結論 ： 推薦使用
- 單例模式在JDK應用的原始碼分析
單例模式在JDK應用的原始碼分析
1）我們JDK中，java.lang.Runtime就是經典的單例模式
2）代碼分析 + Debug原始碼 + 代碼說明
單例模式注意事項和細節說明
1）單例模式保證了系統記憶體中該類只存在一個物件，節省了系統資源，對于一些需要頻繁創建銷毀的物件，使用單例模式可以提高系統性能
2）當想實體化一個單例類的時候，必須要記住使用相應的獲取物件的方法，而不是使用new
3）單例模式使用的場景 ：需要頻繁的進行創建和消費的對方、創建物件時耗時過多或耗費資源過多（即 ： 重量級物件），但又經常用到的物件、工具類物件、頻繁訪問資料庫或者檔案的物件（比如資料源、session工廠等）
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/22721.html
標籤：設計模式