设计模式之—单例设计模式

怼烎@ 2022-11-10 00:55 288阅读 0赞

## 单例设计模式 ##

*  确保某个类只有一个实例，而且自行实例化，并向整个系统提供该实例对象。计算机系统中：线程池、缓存、日志对象、对话框、打印机、显卡驱动等常被设计为单例。
 *  **好处**
    
     *  对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
     *  由于 new 操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻 GC 压力，缩短 GC 停顿时间。

### 特点： ###

*  单例只有一个实例；
 *  该实例自己创建；
 *  对外提供唯一的实例。

## 懒汉式、饿汉式 ##

私有化`private`构造方法，避免类被外界实例化，只能通过自身提供的方法getInstance（）去获得。

### 1、饿汉式：（可用） ###

// 饿汉式单例，在类初始化时，已经自行实例化
    package com.weidd.best.singletontest;
    
    public class Singleton { 
    	// 私有化构造方法
        private Singleton() { 
        }
        // 私有静态对象引用
        private static final Singleton instance = new Singleton();
        // 静态工厂方法
        public static Singleton getInstance() { 
            return instance;
        }
        
        public void doSomething(){ 
            System.out.println("doSomething~");
        }
        
        public static void main(String[] args) { 
            Singleton instance = Singleton.getInstance();
            Singleton instance1 = Singleton.getInstance();
            System.out.println(instance==instance1);
        }
    }

> true

*  饿汉式是天生的线程安全的，在类创建的同时就创建一个静态对象供系统使用，以后不再变。（这样会造成内存资源的一直被占用。）

### 2、懒汉式： ###

*  **线程不安全（不可用）**  
    当两个线程同时进入到`if(null==instance)` 则会创建两个实例对象，与单例设计的定义相悖。

public class Singelton{ 
    	private Singleton(){ }
    	private static Singleton instance= null;
    	public static Singleton getInstance(){ 
    		if(null==instance){ 
    			instance = new Singleton();
    		}
    		return instance;
    	}
    }

此方式会出现线程不安全的情况，不能使用。

*  **线程安全（可用，但是效率较低）**

public class Singelton{ 
    	private Singleton(){ }
    	private static Singleton instance= null;
    	public static synchronized Singleton getInstance(){ 
    		if(null==instance){ 
    			instance = new Singleton();
    		}
    		return instance;
    	}
    }

*  **双重检查（可用，效率和安全兼顾，但是会出现双重检测锁定被破坏的情况）**  
    参看：[http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html][http_www.cs.umd.edu_pugh_java_memoryModel_DoubleCheckedLocking.html]

public class Singleton2 { 
        private Singleton2() { }
     // private static Singleton2 instance;
        private static volatile Singleton2 instance;
        
        public static Singleton2 getInstance() { 
            if (null == instance) { 
                synchronized (Singleton2.class) { 
                    if (null == instance) { 
                        instance = new Singleton2();
                    }
                }
            }
            return instance;
        }
    }

Java支持无需写，导致出现如下情况。  
![双检查][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU1OTI4Mg_size_16_color_FFFFFF_t_70]

> 线程B拿到的是未初始化完成的对象。此时使用会出问题  
> 为了解决此问题问题，需要在instance前加入关键字volatile。使用了volatile关键字后，重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前。 但是只在 JDK5 及之后有效。

*  **静态内部类（可用，最推荐）**

public class Singleton {   
     private Singleton() { }  
     
     private static class Holder {   
    	  private static Singleton instance = new Singleton();  
     }  
     public static Singleton getInstance() {   
      // 外围类能直接访问内部类（不管是否是静态的）的私有变量 
      return Holder.instance;  
    	 }  
     }

*  [静态内部类的加载时机][Link 1]：
    
     *  在类加载时候，不会加载静态内部类，当调用Singleton的getInstance()时才加载，并且加载一次。

#### 饿汉式和懒汉式对比： ####

*  从速度和反应时间角度来讲，非延迟加载（又称饿汉式）好；从资源利用效率上说，延迟加载（又称懒汉式）好。

#### 进一步学习： ####

参考：[https://www.iteye.com/topic/652440][https_www.iteye.com_topic_652440]

[http_www.cs.umd.edu_pugh_java_memoryModel_DoubleCheckedLocking.html]: http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU1OTI4Mg_size_16_color_FFFFFF_t_70]: /images/20221023/1d9f7a87c1ea46bdabde690ba9c30139.png
[Link 1]: https://blog.csdn.net/weixin_39559282/article/details/115048095
[https_www.iteye.com_topic_652440]: https://www.iteye.com/topic/652440