2. 程式人生 > 實用技巧 >設計模式-單例模式

設計模式-單例模式

阿新 • • 發佈：2020-07-14

單例模式模式一般大家都會認為它比較簡單，其實並非你們所認為的那樣，很多情況下，單例模式會涉及到很多優化，下面給大家簡單介紹一下單例模式的幾種演變過程：

  • 餓漢模式
  • 懶漢模式
  • 懶漢模式（加鎖關鍵字 synchronized）
  • 懶漢模式（細粒度的新增synchronized）
  • 懶漢模式（雙重檢查）
  • 靜態內部類
  • 列舉類

第一種：餓漢模式 比較簡單，類載入到記憶體的時候就進行例項化，推薦使用 ，但是有人會說，既然不用幹嘛要進行例項化；

package com.dongl.singleton;

/**
 * 餓漢模式
 * 類載入到記憶體就直接例項化一個單例，JVM會保證它的執行緒安全
 * 簡單使用 推薦使用
 * 缺點:無論用到與否 類載入就會直接例項化
 * 有人就會吹毛求疵說：你不用 你例項化幹嘛？
 
 
*/
public class T01_Singleton {
    private static T01_Singleton INSTANCE = new T01_Singleton();

    public T01_Singleton() {
    }

    public static T01_Singleton  getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) {
        T01_Singleton t1 = T01_Singleton.getInstance();
        T01_Singleton t2 
 
= T01_Singleton.getInstance();
        System.out.println(t1 == t2);
    }
}

第二種：懶漢模式 這種模式在多執行緒的情況下會出現問題

package com.dongl.singleton;


/**
 * 懶漢模式 lazy loading
 * 雖然達到了按需初始化的目的 但是也帶來了執行緒安全的問題
 * 在多執行緒的情況下
 */
public class T02_Singleton {
    private static T02_Singleton INSTANCE = null;

    public T02_Singleton() {
    }

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

    public static void main(String[] args) {
//        T02_Singleton t1 = T02_Singleton.getInstance();
//        T02_Singleton t2 = T02_Singleton.getInstance();
//        System.out.println(t1 == t2);

        /**建立100個執行緒 呼叫getInstance() 列印返回的物件的hashcode()*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(T02_Singleton.getInstance().hashCode());
            }).start();
        }
    }
}

//執行結果 hashcode值不相同

E:\JDK\jdk1.8\bin\java.exe "-javaagent:E:\Idea\IntelliJ IDEA
1365279759
1365279759
1365279759
1945255694
226994615




第三種：懶漢模式（加鎖關鍵字 synchronized）這種方式解決了懶漢模式下多執行緒問題，但是同時帶來的問題是效率降低；



package com.dongl.singleton;


/**
 * 懶漢模式 lazy loading
 * 雖然達到了按需初始化的目的 但是也帶來了執行緒安全的問題
 * 解決辦法使用synchronized 但是帶來的問題就是效率下降
 */
public class T03_Singleton {
    private static T03_Singleton INSTANCE = null;

    public T03_Singleton() {
    }

    /**
     * 加鎖的方式有兩種 一種是對方法進行加鎖 另一種是對程式碼塊進行加鎖
     * 涉及到的無非是鎖的粒度問題
     * @return
     */
    public static /**synchronized*/ T03_Singleton getInstance(){
        synchronized (T02_Singleton.class) {
            if (INSTANCE == null) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new T03_Singleton();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        /**建立100個執行緒 呼叫getInstance() 列印返回的物件的hashcode()*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(T03_Singleton.getInstance().hashCode());
            }).start();
        }
    }
}



第四種：懶漢模式（細粒度的新增synchronized）試圖通過減小鎖的粒度來進行改善效率的問題 但是不可行；



package com.dongl.singleton;


/**
 * 懶漢模式 lazy loading
 * 雖然達到了按需初始化的目的 但是也帶來了執行緒安全的問題
 * 解決辦法使用synchronized 但是帶來的問題就是效率下降
 *
 * 試圖通過減小鎖的粒度來進行改善效率的問題  但是不可行
 */
public class T04_Singleton {
    private static T04_Singleton INSTANCE = null;

    public T04_Singleton() {
    }

    public static /**synchronized*/ T04_Singleton getInstance(){
        if (INSTANCE == null) {
            //試圖通過減小鎖的粒度來進行改善效率的問題  但是不可行
            synchronized (T02_Singleton.class) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new T04_Singleton();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        /**建立100個執行緒 呼叫getInstance() 列印返回的物件的hashcode()*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(T04_Singleton.getInstance().hashCode());
            }).start();
        }
    }
}



第五種：懶漢模式（雙重檢查）這種方式解決了多執行緒帶來的問題；



package com.dongl.singleton;


/**
 * 懶漢模式 lazy loading
 * 雖然達到了按需初始化的目的 但是也帶來了執行緒安全的問題
 * 解決辦法使用synchronized 但是帶來的問題就是效率下降
 * 因為鎖的粒度很小也會帶來多執行緒問題
 * 這時可以使用雙重檢查 來避免
 */
public class T05_Singleton {
    private volatile static T05_Singleton INSTANCE = null;

    public T05_Singleton() {
    }

    public static /**synchronized*/
    T05_Singleton getInstance(){
        if (INSTANCE == null) {
            synchronized (T02_Singleton.class) {
                //雙重檢查
                if(INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new T05_Singleton();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        /**建立100個執行緒 呼叫getInstance() 列印返回的物件的hashcode()*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(T05_Singleton.getInstance().hashCode());
            }).start();
        }
    }
}



第六種：靜態內部類實現懶載入（lazy loading）這種方式是最優解之一 因為在載入類的時候 不載入內部類這樣就實現了懶載入；



package com.dongl.singleton;


/**
 * 靜態內部類的法方法
 * JVM保證單例
 * 載入外部類的時候 不會載入內部類 這樣實現了懶載入
 */
public class T06_Singleton {

    public T06_Singleton() {
    }

    //靜態內部類
    private static class T06_SingletonHandler{
        private final static T06_Singleton INSTANCE = new T06_Singleton();
    }

    public static T06_Singleton getInstance(){
        T06_Singleton instance = T06_SingletonHandler.INSTANCE;
        return instance;
    }

    public static void main(String[] args) {
        /**建立100個執行緒 呼叫getInstance() 列印返回的物件的hashcode()*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(T06_Singleton.getInstance().hashCode());
            }).start();
        }
    }
}



第七種：列舉類不僅可以解決執行緒同步，還可以防止反序列化。



package com.dongl.singleton;


/**
 * 不僅可以解決執行緒同步，還可以防止反序列化。
 */
public enum  T07_Singleton {

    INSTANCE;

    public static void main(String[] args) {
        /**建立100個執行緒 呼叫getInstance() 列印返回的物件的hashcode()*/
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(T07_Singleton.INSTANCE.hashCode());
            }).start();
        }
    }
}



以上其中方式是按照問題出現 一步步的優化得到的，如果你覺得有疑問可以評論區說出你的觀點，一起討論一起進步！！！
   
 
 
 

             
          

            
  

           

               
              
             

            

            

            
相關推薦

			   
            
            
            
 

    


    
    
設計模式 - 單例模式（詳解）看看和你理解的是否一樣？

    
一、概述
單例模式是設計模式中相對簡單且非常常見的一種設計模式，但是同時也是非常經典的高頻面試題，相信還是有很多人在面試時會掛在這裡。本篇文章主要針對單例模式做一個回顧，記錄單例模式的應用場景、常見寫法
 


  
 

    


    
    
Java設計模式單例模式(Singleton)用法解析

    
這篇文章主要介紹了Java設計模式單例模式(Singleton)用法詳解,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
 


  
 

    


    
    
javascript設計模式 – 單例模式原理與應用例項分析

    
本文例項講述了javascript設計模式 – 單例模式。分享給大家供大家參考，具體如下：
 


  
 

    


    
    
JavaScript設計模式---單例模式詳解【四種基本形式】

    
本文例項講述了JavaScript設計模式---單例模式.分享給大家供大家參考，具體如下：
 


  
 

    


    
    
Java設計模式——單例模式

    
類的單例設計模式：採取一定的方法保證在整個的軟體系統中，對某個類只能存在一個物件例項，並且該類只提供一個取得其物件例項的方法靜態方法 。
 


  
 

    


    
    
設計模式-單例模式

    
單例模式模式一般大家都會認為它比較簡單，其實並非你們所認為的那樣，很多情況下，單例模式會涉及到很多優化，下面給大家簡單介紹一下單例模式的幾種演變過程：
 


  
 

    


    
    
php設計模式-單例模式

    
<?php
//簡單的單例
class Singleleton {
private static $_instance = null;

public static function getSingleleton()
 


  
 

    


    
    
設計模式-單例模式的實現

    
單例模式
面試官所認為的單例模式
單例模式（詳解，面試問題）

單例模式的實現方式
 


  
 

    


    
    
設計模式  --單例模式

    
前言
單例模式應該是我們最熟悉的模式了，如果說要隨便抓一個程式設計師，讓他說一說最熟悉的集中設計模式，我想肯定有單例模式。
 


  
 

    


    
    
java設計模式-單例模式

    
package 單例模式;

/*
 * 餓漢式
 * 類載入到記憶體後 就例項化一個單例 JVM保證了執行緒安全
 


  
 

    


    
    
設計模式(單例模式)

    
一 、簡介
 　　所謂類的單例設計模式，就是 採取一定的方法保證在整個的軟體系統中，對某個類只能存在一個物件例項，並且該類只提供一個取得其物件例項的方法(靜態方法)。 ​ 比如 Hibernate 的 SessionFactory，它
 


  
 

    


    
    
設計模式——單例模式

    
單例模式
通常我們可以讓一個全域性變數使得一個物件被訪問， 但它不能防止你例項化多個物件。
 


  
 

    


    
    
C#設計模式——單例模式

    
一、單例模式的介紹
 什麼是單例模式，官方定義的是：確保一個類只有一個例項，並提供一個全域性訪問點。
 


  
 

    


    
    
設計模式 -- 單例模式

    
1在JAVA當中，如果我們需要建立一個物件，一般是通過該類new（）一個物件，但是如果在程式當中很多地方都
 


  
 

    


    
    
js設計模式——單例模式

    
什麼是單例模式
保證一個類僅有一個例項，並提供一個訪問它的全域性訪問點。
 


  
 

    


    
    
java之設計模式-單例模式

    
1.定義：指一個類只有一個例項，且該類能自行建立這個例項的一種模式。例如，Windows只能開啟一個工作管理員，這樣可以避免因開啟多個工作管理員視窗而造成記憶體資源的浪費，或出現各個視窗顯示內容不一致等錯誤。
 


  
 

    


    
    
設計模式--單例模式

    
模式定義；保證一個類只有一個例項，並且提供一個全域性訪問點。
應用場景：重量級的物件，不需要多個例項，如執行緒池，資料庫連線池。就是被複用的。。
 


  
 

    


    
    
設計模式 - 單例模式的8種寫法 ( Singleton )

    
. 阻止別人建立第二個例項
.
總共有8種寫法
.
第1種 餓漢式
 不算完美, 但是比較實用, 所以比較推薦 一般程式設計師不太會去呼叫Class.forName(), 也就不會觸發new例項
 


  
 

    


    
    
設計模式---單例模式

    
一、模式設計（Design pattern）

單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。
 


  
 

    


    
    
常用設計模式-單例模式

    
單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。