设计模式之单例模式的八种实现方式

╰半夏微凉° 2022-10-20 13:40 191阅读 0赞

**阅读本文章之前需要了解序列化、枚举、指令重排和volatile，传送地址：  
[Java并发编程之Java内存模型][Java_Java]  
[Java序列化、反序列化机制][Java]  
[Java枚举机制][Java 1]**

# 单例模式 #

### 文章目录 ###

*  单例模式
 *   *  一、单例模式的介绍
     *  二、饿汉式
     *   *  1. 静态属性方式
         *  2. 静态代码块方式
         *  3. 枚举方式
     *  三、懒汉式
     *   *  1. synchronized关键字方式
         *  2. 双重检查锁方式 (DCL)
         *   *  2.1 DCL空指针异常的原因
             *  2.2 解决空指针异常的方式
         *  3. 静态内部类方式
     *  四、破坏单例模式的方式
     *   *  1. 序列化 / 反序列化
         *   *  1.1 解决方法
         *  2. 反射
         *   *  2.1 解决方法

## 一、单例模式的介绍 ##

*  单例模式属于创建型模式，它提供了一种创建对象的最佳方式
 *  类本身负责创建自己的对象，同时确保只有单个对象被创建，这个类提供了一个访问其唯一对象的方法，从而可以直接访问该对象
    
     *  在类外不允许实例化该类的对象，只能调用类中创建的唯一对象
 *  单例模式分为两种类型
    
     *  饿汉式：类加载就会导致该单实例对象被创建
     *  懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

## 二、饿汉式 ##

### 1. 静态属性方式 ###

public class Singleton { 
    
        //1，私有构造方法，使得外界无法访问构造器，从而无法创建对象
        private Singleton() { }
    
        //2，在本类中创建本类对象，声明为私有的
        //由于类提供的访问方式是静态的，导致此变量必须也是静态的
        private static Singleton instance = new Singleton();
    
        //3，提供一个公共的（public）访问方式，让外界获取该对象
        //必须使用static修饰，否则外界必须创建对象才能调用此方法
        public static Singleton getInstance() { 
            return instance;
        }
    }

缺点：instance对象是随着类的加载而创建的，如果该对象非常大，而且一直没有使用就会造成内存的浪费

### 2. 静态代码块方式 ###

public class Singleton { 
    
        //私有构造方法
        private Singleton() { }
    
        //声明私有的Singleton类型的对象
        private static Singleton instance; //默认值为null
    
        //在静态代码块中进行赋值
        static { 
            instance = new Singleton();
        }
    
        //对外提供获取该类对象的方法
        public static Singleton getInstance() { 
            return instance;
        }
    }

缺点：instance对象是随着类的加载而创建的，如果该对象非常大，而且一直没有使用就会造成内存的浪费

### 3. 枚举方式 ###

关于枚举的详细介绍见文档 / 博客

public enum Singleton { 
        INSTANCE;
    }

特点：

*  枚举类是线程安全的
 *  只会装载一次，从而保证了单例
 *  枚举方式是所有单例实现中唯一一种不会被破坏的单例实现模式
 *  写法十分简单

## 三、懒汉式 ##

### 1. synchronized关键字方式 ###

public class Singleton { 
    
        //私有构造方法
        private Singleton() { }
    
        //声明Singleton类型的变量instance
        private static Singleton instance; //只是声明一个该类型的变量，并没有进行赋值
    
        //对外提供访问方式
        //首次使用才创建，首次使用指的是调用getInstance方法
        //不能直接new，每次调用都会new，导致非单实例，需要进行判断从而决定是否new
        //必须保证线程安全
        public static synchronized Singleton getInstance() { 
            //判断instance是否为null，如果为null，说明还没有创建对象
            //如果没有创建对象，则创建一个并返回
            //如果不等于null，即已经创建了对象，则直接返回
            if(instance == null) { 
                instance = new Singleton();
            }
            return instance;
        }
    }

特点：

*  如果没有加 `synchronized` 关键字，则线程不安全（这也算是一种单例的实现方式）
    
     *  t1线程判断得到 `instance == null` ，但没有执行到new对象，此时时间片切换到了t2线程，也判断得到 `instance == null` ，也会去new对象，非单实例，线程不安全
 *  `synchronized` 属于重量级锁，会导致该方法的执行效率特别低

### 2. 双重检查锁方式 (DCL) ###

*  DCL 即 Double Check lock
 *  对于 `getInstance()` 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以没必要让每个线程必须持有锁才能调用该方法，需要调整加锁的时机， `getInstance()` 方法无需添加 `synchronized` 关键字，写操作时才需要加锁，这种方式称为双重检查锁方式

public class Singleton { 
    
        //私有构造方法
        private Singleton() { }
    
        //声明Singleton类型的变量
        private static Singleton instance;
    
        //对外提供公共的访问方式
        public static Singleton getInstance() { 
    
            //第一次判断
            //如果instance的值不为null，不需要抢占锁，直接返回对象，提升读操作的效率
            if(instance == null) { 
    
                synchronized (Singleton.class) { 
    
                    //第二次判断
                    //如果t1线程判断第一个if条件为true，加锁之前切换到了t2线程，
                    //t2线程判断第一个if条件为true，并执行完了此方法，t2线程创建了对象，
                    //切换回t1线程，如果不再次判断对象是否已经创建，则会加锁之后创建一个新的对象，
                    //不满足单例的要求
    
                    if(instance == null) { 
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

缺点：

DCL方式存在空指针异常的问题，出现的原因是因为 JVM 的指令重排机制

#### 2.1 DCL空指针异常的原因 ####

观察自定义的 `getInstance()` 方法：

public static Singleton getInstance() { 
        if(instance == null) {  //语句1
            synchronized (Singleton.class) { 
                if(instance == null) { 
                    instance = new Singleton(); //语句2
                }
            }
        }
        return instance; //语句3
    }

重点分析语句2，new操作在更细的层面分为以下三个步骤:

*  分配新对象内存
 *  调用类构造器初始化成员变量
 *  instance被赋为指向新对象的引用

经过指令重排可能形成以下新顺序：

*  分配新对象内存
 *  instance被赋为指向新对象的引用
 *  调用类构造器初始化成员变量

根据新顺序分析一种异常场景：

*  线程1执行到语句2，执行到 “instance被赋为指向新对象的引用” 这个步骤，还没有初始化对象
 *  此时线程2执行到语句1，由于instance已经被赋为指向新对象的引用，instance已经不等于null，所以可以执行到语句3
 *  但是语句3返回的是没有进行初始化的对象，所以使用这个对象就会抛出空指针异常

#### 2.2 解决空指针异常的方式 ####

要解决双重检查锁模式带来的空指针异常问题，只需要使用 `volatile` 关键字， `volatile` 关键字可以保证可见性和有序性，修改一行代码即可：

（添加 volatile 关键字也算是一种单例的实现方式）

private static volatile Singleton instance;

### 3. 静态内部类方式 ###

JVM 在加载外部类的过程中，是不会加载静态内部类的，只有内部类的 属性 / 方法 被调用时才会被加载，并初始化其静态属性。静态属性由于被 `static` 修饰，保证只被实例化一次，从而保证了单例

public class Singleton { 
    
        //私有构造方法
        private Singleton() { }
    
        //定义一个静态内部类
        private static class SingletonHolder { 
            //在内部类中声明并初始化外部类的对象
            private static final Singleton INSTANCE = new Singleton();
        }
    
        //提供公共的访问方式
        public static Singleton getInstance() { 
            return SingletonHolder.INSTANCE;
        }
    }

特点：

在没有加任何锁的情况下，保证了多线程下的安全（类加载是线程安全的），并且没有任何性能影响和空间的浪费

## 四、破坏单例模式的方式 ##

除了枚举方式之外，其余的方式都有可能被破坏（创建多个不同的对象）

### 1. 序列化 / 反序列化 ###

关于序列化 / 反序列化的相关知识可以查看博客 / 文档

将单例对象序列化到本地，再从本地反序列化，多次执行反序列化时得到的是不同的对象，破坏了单例模式

#### 1.1 解决方法 ####

在 `Singleton` 类中添加 `readResolve()` 方法，在反序列化时此方法自动的被反射调用，如果定义了这个方法，反序列化时就返回这个方法的返回值，如果没有定义，则返回新new出来的对象：

//Singleton类中定义此方法
    private Object readResolve() {     
    	return SingletonHolder.INSTANCE;
    }

### 2. 反射 ###

执行如下的反射代码，获取对象：

public class Test {     
    	public static void main(String[] args) throws Exception {    
    	     
    	//获取Singleton类的字节码对象 
    	Class clazz = Singleton.class;  
    	      
    	//获取Singleton类的私有无参构造方法对象 
    	Constructor constructor = clazz.getDeclaredConstructor();     
    	   
    	//取消访问检查 
    	constructor.setAccessible(true);  
    	      
    	//创建Singleton类的对象s1 
    	Singleton s1 = (Singleton) constructor.newInstance();        
    	//创建Singleton类的对象s2 
    	Singleton s2 = (Singleton) constructor.newInstance();    
    	    
    	//判断通过反射创建的两个Singleton对象是否是同一个对象 
    	System.out.println(s1 == s2); //false 
    	//如果返回的是true，说明并没有破坏单例模式，如果是false，说明破坏了单例模式 
    	}
    }

#### 2.1 解决方法 ####

通过反射创建多个不同的对象时，只需要抛出异常即可：

public class Singleton {     
    
    	//私有构造方法 
    	private Singleton() {   
    	      
    		//反射破坏单例模式时抛出异常 
    		if(instance != null) {             
    			throw new RuntimeException("不满足单例模式！");        
    		}    
    	}    
    	
    	private static volatile Singleton instance;  
    	  
    	//对外提供静态方法获取该对象 
    	public static Singleton getInstance() {      
    	   
    		if(instance != null) {             
    			return instance;        
    		}      
    		  
    		synchronized (Singleton.class) {             
    			if(instance != null) {                 
    				return instance;            
    			}            
    			instance = new Singleton();            
    			return instance;        
    		}    
    	}
    }

[Java_Java]: https://blog.csdn.net/weixin_49343190/article/details/114963823
[Java]: https://blog.csdn.net/weixin_49343190/article/details/116733865
[Java 1]: https://blog.csdn.net/weixin_49343190/article/details/116779140