设计模式之单例模式（附代码实现）

设计模式之单例模式

初步理解

简介

​ 在三大类设计模式中（共计23种），可以分为 创建型模式、行为型模式、结构性模式，单例模式 属于创建型模式中的一种。

​ 单例模式确保某个类在系统中只有一个实例，并提供一个全局访问入口。

特点

• 单例类只能有一个实例。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。
• 隐藏所有的构造方法。

实现思路

1. 一个类能返回对象的一个引用（每次都是同一个），和一个获得该实例的方法（必须是静态方法，通常使用 getInstance 这个名称）。
2. 调用获取实例的方法时，有两种情况：如果类持有的引用不为空，则返回该引用；如果为空，则创建该类的实例并返回其实例的应用。
3. 将该类的构造函数定义为私有方法，可以确保无法在其他处通过调用该类的构造方法对该类进行实例化，保证了只有通过该类提供的静态方法才能得到该类的唯一实例。

常见使用场景

• 日志类
• 配置类
• 工厂类
• 数据库连接池的设计
• 多线程线程池的设计
• 以共享模式访问资源的类

优点

• 在内存中只有一个对象，节省内存空间；
• 避免频繁的创建销毁对象，减轻 GC 工作，同时可以提高性能；
• 避免对共享资源的多重占用，简化访问；
• 为整个系统提供一个全局访问点。

缺点

• 不适用于变化频繁的对象；
• 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；
• 如果实例化的对象长时间不被利用，系统会认为该对象是垃圾而被回收，这可能会导致对象状态的丢失；

代码实现（8种方式）

参考自 小傅哥《重学设计模式》

1. 使用静态类

public class Singleton_00 {
	public static Map<String, String> cache = new ConcurrentHashMap<String, String>();
}

• 这种使用静态类的方式，可以在第一次运行的时候直接初始化该静态类，适合在不需要延迟加载的场景中使用。
• 在不需要维持任何状态下，仅仅用于全局访问，这样使用静态类的方式更加方便。

2. 懒汉模式（线程不安全）

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

• 这种实现在多线程的环境下，可能会发生多个实例并存的情况，没有完全达到单例模式的要求。

3. 懒汉模式（线程安全）

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

• 在 getInstance 方法上加上 synchronized 关键字（加锁），保证在多线程环境下，只有一个线程能执行此方法。
• 此种实现虽然是线程安全的，但由于把锁加到方法上后，所有的访问都因需要锁的占用从而导致资源的浪费。如果不是特殊情况下，不建议采用此种方法实现单例模式。

4. 饿汉模式（线程安全）

public class Singleton_03 {
    private static Singleton_03 instance = new Singleton_03();
    
    private Singleton_03() {}
    
    public static Singleton_03 getInstance() {
        return instance;
    }
}

• 此种方法和第一种实例化 Map 的方法基本一致，在程序启动时直接运行加载，后续有内部类需要使用的时候再获取即可。
• 但这种方式不适用于需要懒加载的实例。

5. 使用类的内部类

public class Singleton_04 {
    private static class SingletonHolder {
        private static Singleton_04 instance = new Singleton_04();
    }
    
    private Singleton_04() {}
    
    public static Singleton_04 getInstance() {
        return SingletonHolder.instance;
    }
}

• 使用类的静态内部类实现的单例模式，既保证了线程安全，又保证了懒加载，同时也不会因为加锁的方式损耗性能。
• 这主要是因为 JVM 可以保证多线程并发访问的正确性，也就是一个类的构造方法在多线程的环境下可以被正确地加载。
• 此种方式也是非常推荐使用的一种方式。

6. 懒汉模式（双重锁校验）

public class Singleton_05 {
    private static Singleton_05 instance;
    
    private Singleton_05() {}
    
    public static Singleton_05 getInstance(){
        if(null != instance) return instance;
        synchronized (Singleton_05.class){
            if (null == instance){
                instance = new Singleton_05();
            }
        }
        return instance;
    }
}

• 对懒汉模式的改进，满足了懒加载。
• 双重锁的方式，是方法级锁的优化，减少了部分获取实例的耗时。

7. CAS [AtomicReference] (线程安全）

public class Singleton_06 {
	private static final AtomicReference<Singleton_06> INSTANCE = new AtomicReference<Singleton_06>();
    
	private static Singleton_06 instance;
    
	private Singleton_06() {}
    
    public static final Singleton_06 getInstance() {
       for (; ; ) {
           Singleton_06 instance = INSTANCE.get();
           if (null != instance) return instance;
           INSTANCE.compareAndSet(null, new Singleton_06());
           return INSTANCE.get();
        }
    }
    
    public static void main(String[] args) {
        System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d
        System.out.println(Singleton_06.getInstance()); // org.itstack.demo.design.Singleton_06@2b193f2d
    }
}

https://mp.weixin.qq.com/s/F04CmkcqSBS4cC7n3zPrLg

• java 并发库提供了很多原子类来支持并发访问的数据安全性：AtomicInteger、AtomicBoolean、AtomicLong、AtomicReference。
• AtomicReference 可以封装引用一个 V 实例，支持并发访问如上的单例方式就是使用了这样的一个特点。
• 使用 CAS 的好处就是不需要使用传统的加锁方式来保证线程安全，而是依赖于 CAS 的忙等算法，依赖于底层硬件的实现，来保证线程安全。相对于其他锁的实现没有线程的切换和阻塞也就没有了额外的开销，并且可以支持较大的并发性。
• 当然 CAS 也有一个缺点就是忙等，如果一直没有获取到则会处于死循环中。

8. 枚举单例（线程安全， Effective Java 作者推荐）

public enum Singleton_07 {
	INSTANCE;
	public void test(){
		System.out.println("hi~");
	}
}

• Effective Java 作者推荐使用枚举的方式解决单例模式，此种方法可能是平时最少用到的。
• 这种方式解决了最主要的问题：线程安全、自由串行化、单一实例。