【设计模式】创建型：单例模式（一）单例的五种写法

电玩女神 2023-01-15 08:08 164阅读 0赞

单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是**创建型**模式。

在 J2EE 标准中，ServletContext、 ServletContextConfig 都是单例的；还有在 Spring 框架应用中 ApplicationContext 也是唯一的；另外，数据库的连接池也都是单例形式。单例模式在现实生活中应用也非常广泛，比如企业的总裁是唯一的。

> 单例模式可以保证内存里只有一个实例，减少了内存开销；可以避免对资源的多重占用。

### 1.饿汉式单例 ###

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题。

*  优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好
 *  缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，有可能占着茅坑不拉屎

> PS：Spring 中 IOC 容器 ApplicationContext 本身就是典型的饿汉式单例。接下来看一段代码：

public class HungrySingleton {
        
    
        private static final HungrySingleton hungrySingleton = new HungrySingleton();
        
        private HungrySingleton(){
        }
        
        public static HungrySingleton getInstance(){
        
        	return hungrySingleton;
        }
    }

还有另外一种写法，利用静态代码块的机制：

//饿汉式静态块单例
    public class HungryStaticSingleton {
        
    	private static final HungryStaticSingleton hungrySingleton;
        
        static {
        
        	hungrySingleton = new HungryStaticSingleton();
        }
       
        private HungryStaticSingleton(){
        }
        
        public static HungryStaticSingleton getInstance(){
        
        	return hungrySingleton;
        }
    }

这两种写法都非常的简单，也非常好理解，饿汉式适用在单例对象较少的情况。下面我们来看性能更优的写法。

### 2.懒汉式单例 ###

懒汉式单例的特点是：被外部类调用的时候内部类才会加载。

下面看懒汉式单例的简单实现 LazySimpleSingleton：

// 懒汉式单例
    // 在外部需要使用的时候才进行实例化
    public class LazySimpleSingleton {
        
        private LazySimpleSingleton(){
        }
        // 静态块，公共内存区域
        private static LazySimpleSingleton lazy = null;
        
        public static LazySimpleSingleton getInstance(){
        
            if(lazy == null){
        
                lazy = new LazySimpleSingleton();
            }
            return lazy;
        }
    }

但这种写法存在线程安全问题，因为可能线程一刚好走到 lazy=null 后就让出了 CPU，那么线程二再来判断时 lazy仍然为 null，所以此时一共会创建两个对象。

所以，我们可以通过给 getInstance() 加上 synchronized 关键字来保证线程安全

public class LazySimpleSingleton {
        
        private LazySimpleSingleton(){
        }
        // 静态块，公共内存区域
        private static LazySimpleSingleton lazy = null;
        // synchronized
        public synchronized static LazySimpleSingleton getInstance(){
        
            if(lazy == null){
        
            	lazy = new LazySimpleSingleton();
            }
            return lazy;
        }
    }

但是，用 synchronized 加锁，在线程数量比较多情况下，如果 CPU 分配压力上升，会导致大批量线程出现阻塞，从而导致程序运行性能大幅下降。那么，有没有一种更好的方式，既兼顾线程安全又提升程序性能呢？答案是肯定的。我们下面来看双重检查锁的单例模式。

### 3.DCL 单例 ###

看下面的代码，

public class LazyDoubleCheckSingleton {
        
        
        // volatile 防止半初始化
        private volatile static LazyDoubleCheckSingleton lazy = null;
        
        private LazyDoubleCheckSingleton(){
        }
        
        public static LazyDoubleCheckSingleton getInstance(){
        
            if(lazy == null){
        
            	synchronized (LazyDoubleCheckSingleton.class){
        
                    if(lazy == null){
        
                        lazy = new LazyDoubleCheckSingleton();
                        // 1.分配内存给这个对象
                        // 2.初始化对象
                        // 3.设置 lazy 指向刚分配的内存地址
                     }
                }
            }
            return lazy;
        }
    }

当第一个线程调用 getInstance()方法时，第二个线程也可以调用 getInstance()。当第一个线程执行到 synchronized 时会上锁，第二个线程就会变成 MONITOR 状态，出现阻塞。此时，阻塞并不是基于整个 LazySimpleSingleton 类的阻塞，而是在 getInstance() 方法内部阻塞，只要逻辑不是太复杂，对于调用者而言感知不到。

但是，用到 synchronized 关键字，总归是要上锁，对程序性能还是存在一定影响的。难道就真的没有更好的方案吗？当然是有的。我们可以从类初始化角度来考虑，采用静态内部类的方式。

### 4.静态内部类 ###

首先，我们要明白，内部类是延时加载的，也就是说只会在第一次使用时加载。不使用就不加载。

看下面的代码，

// 这种形式兼顾饿汉式的内存浪费，也兼顾 synchronized 性能问题
    // 完美地屏蔽了这两个缺点
    public class LazyInnerClassSingleton {
        
    	// 默认使用 LazyInnerClassGeneral 的时候，会先初始化内部类
        // 如果没使用的话，内部类是不加载的
        private LazyInnerClassSingleton(){
        }
        
        // 每一个关键字都不是多余的
        // static 是为了使单例的空间共享
        // final 保证这个方法不会被重写，重载
        public static final LazyInnerClassSingleton getInstance(){
        
            // 在返回结果以前，一定会先加载内部类
            return LazyHolder.LAZY;
        }
        
        // 默认不加载
        private static class LazyHolder{
        
        	private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
        }
    }

这种形式兼顾饿汉式的内存浪费，也兼顾 synchronized 性能问题。内部类一定是要在方 法调用之前初始化，巧妙地避免了线程安全问题。

### 5.枚举单例 ###

枚举式单例也是《Effective Java》书中推荐的一种单例实现写法，它不仅写法简洁，更重要的是它避免了反射破坏单例，以及序列化破坏单例问题，让枚举式单例成为一种比较优雅的实现。

public enum EnumSingleton {
        
        INSTANCE;
    }

当要获取单例时，我们直接 EnumSingleton.INSTANCE 就可以拿到。

但我们在实际使用时，一般不是直接获取，而是通过一个 getInstance() 间接获取。另外，我们还可以给这个单例添加 EnumSingleton 的单例添加成员变量，以及成员方法

public enum EnumSingleton {
        
        INSTANCE;
    	
    	// 单例的成员变量
        private Object data;
        // 单例的成员方法
        // 调用方式是 EnumSingleton.getInstance().getData()
        public Object getData() {
        
        	return data;
        }
        // 单例的成员方法
        public void setData(Object data) {
        
        	this.data = data;
        }
    	
    	// 通过 getInstance() 获取单例对象
    	// 调用方式是 EnumSingleton.getInstance()
        public static EnumSingleton getInstance(){
        
        	return INSTANCE;
        }
    }