【Java开发】设计模式 01：单例模式

1 单例模式介绍

单例模式（Singleton Pattern）是Java中最为基础的设计模式。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.1 场景

• 目的：控制实例数目，节省系统资源；

• 适用：若一个全局使用的类频繁地创建与销毁，单例模式可以证一个类仅有一个实例，并提供一个访问它的全局访问点。

1. 要求生产唯一序列号；

2. WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来；

3. 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

• 优点：

1. 如此内存中只有一个实例，减少了内存的开销；

2. 避免对资源的多重占用（比如写文件操作）。

• 缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

注：spring boot项目中将该对象注入到bean，那么该对象就默认为单例，这时也可以使用@Scope去设定单例和原型以及其他模式。

1.2基础实现方式

以下是基础的实现方式，创建一个 Singleton 类，存在私有构造函数和本身的一个静态实例。

Singleton 类提供了一个静态方法，供外界获取它的静态实例。Client，我们的演示类使用 Singleton 类来获取 Singleton 对象。

📌 1.创建Singleton单例类

public class Singleton {

    //让构造函数为 private，这样该类就不会被实例化
    private Singleton(){}

    //创建 SingleObject 的一个对象
    private static Singleton INSTANCE = new Singleton();

    //获取唯一可用的对象
    public static Singleton getInstance(){
        return INSTANCE;
    }

}

📌 2.从singleton类获取唯一的对象。

public class Client {
    public static void main(String[] args) {
        //不合法的构造函数--因为SingleObject()私有，不可见
//        Singleton singleton = new Singleton();

        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        System.out.println(singleton1);
        System.out.println(singleton2);
    }
}

控制台输出：

2 实现方式汇总

类型	Lazy 初始化	多线程安全	实现难度
懒汉式--线程不安全	是	否	容易
懒汉式--线程安全	是	是	容易
饿汉式	否	是	容易
双重校验锁	是	是	较复杂
双重校验锁+volatile	是	是	较复杂
静态内部类	是	是	一般
枚举	否	是	容易
ThreadLocal	是	是	较复杂
CAS锁	是	是	较复杂

2.1 懒汉式--线程不安全

这种方式是最基本的实现方式，最大的问题是不支持多线程，因为没有加锁 synchronized，所以严格意义上它并不算单例模式。

public class Lazyman1 {

    private static Lazyman1 instance;

    private Lazyman1(){}

    public static Lazyman1 getInstance() {
        if (instance == null){
            instance = new Lazyman1();
        }
        return instance;
    }
}

接下来介绍的几种实现方式都支持多线程，但是在性能上有所差异。

2.2 懒汉式--线程安全

这种方式能够在多线程中很好的工作，但是效率低。

优点：第一次调用才初始化，避免内存浪费。

缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

public class Lazyman2 {

    private static Lazyman2 instance;

    private Lazyman2(){}

    public static synchronized Lazyman2 getInstance() {
        if (instance == null){
            instance = new Lazyman2();
        }
        return instance;
    }
}

2.3 饿汉式

这种方式比较常用，但容易产生垃圾对象。它基于类加载机制避免了多线程的同步问题，因为类加载过程JVM会自动加锁，因此保证了单例特性。

优点：没有加锁，执行效率会提高。

缺点：类加载时就初始化，浪费内存。

public class Hungry {

    private Hungry(){}

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

2.4 双重校验锁（DCL，即 double-checked locking）

这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

不过DCL还是可能会出现指令重排的问题~

public class DLC {

    private static DLC instance;

    private DLC(){}

    public static DLC getInstance() {
        if (instance==null){
            synchronized (LazyMan.class){
                if (instance==null){
                    instance = new DLC();//不是一个原子性操作
                    /*
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 可能：
                     * 123
                     * 132 若多线程，A到达3,B会认为lazyMan非空，但是lazyMan此时还没有完成构造，那么就会有问题
                     */
                }
            }
        }
        return instance;
    }
}

2.5 双重校验锁+volatile

用于处理DCL可能出现的问题（指令重排）

解决方案：只需要给instance的声明加上volatile关键字（volatile--静止指令重排），对它的写操作就会有一个内存屏障。

public class DLCVolatile {

    private static volatile DLCVolatile instance;

    private DLCVolatile(){}

    public static DLCVolatile getInstance() {
        if (instance==null){
            synchronized (LazyMan.class){
                if (instance==null){
                    instance = new DLCVolatile();
                }
            }
        }
        return instance;
    }
}

2.6 静态内部类

也称为登记类，这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

这种方式也利用了类加载机制保证初始化instance时只有一个线程，他和饿汉式不同在于：饿汉式只要单例类被加载，那么instance就会被实例化；而静态内部类类加载后，instance不一定被初始化，因为InnerClass类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载InnerClass类，从而实例化instance。

//静态内部类
public class Holder {
    private Holder(){}

    public static Holder getInstance(){
        return InnerClass.INSTANCE ;
    }

    public static class InnerClass{
        private static final Holder INSTANCE  = new Holder();
    }
}

2.7 枚举

实现单例模式的最佳方法，简洁，自动支持序列化机制，防止多次实例化。

这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，在实际工作中很少用。

📌 实现方式

public enum EnumSignle {

    INSTANCE;

    public EnumSignle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main(String[] args) {
        EnumSignle enumSignle1 = EnumSignle.INSTANCE;
        EnumSignle enumSignle2 = EnumSignle.INSTANCE;
        System.out.println(enumSignle1);
        System.out.println(enumSignle2);
    }
}

控制台输出：

📌 通过枚举将已有类改造为单例类

public class Singleton {
    private Singleton(){}
    
    public static enum EnumSignle1 {
        INSTANCE;
        
        private Singleton instance = null;
        
        private EnumSignle1(){
            instance = new Singleton();
        }
        
        public Singleton getInstance(){
            return instance;
        }
    }
}

class Test1{
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.EnumSignle1.INSTANCE.getInstance();
        Singleton singleton2 = Singleton.EnumSignle1.INSTANCE.getInstance();
        System.out.println(singleton1 ==singleton2);
    }
}

2.8 ThreadLocal--线程安全

ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

public class TLSingleton {

    private static final ThreadLocal<TLSingleton> tlSingleton = new ThreadLocal<TLSingleton>(){
        @Override
        protected TLSingleton initialValue() {
            return new TLSingleton();
        }
    };
    
    private TLSingleton(){}

    public static TLSingleton getInstance() {
        return tlSingleton.get();
    }
}

2.9 CAS锁实现（线程安全）

public class CASSingleton {

    private CASSingleton(){}

    private static final AtomicReference<CASSingleton> INSTANCE = new AtomicReference<CASSingleton>();

    public static CASSingleton getInstance() {
        for (; ; ) {
            CASSingleton current = INSTANCE.get();

            if (current != null) {
                return current;
            }

            current = new CASSingleton();

            if (INSTANCE.compareAndSet(null, current)) {
                return current;
            }
        }
    }
}

📌 总结

一般情况下，不建议使用第1种和第2种懒汉方式，建议使用第3种饿汉方式。只有在要明确实现lazy loading效果时，才会使用第6种静态内部类方式。如果涉及到反序列化创建对象时，可以尝试使用第7种枚举方式。如果有其他特殊的需求，可以考虑使用第4种双检锁方式。