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 实现方式汇总

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>(){@Overrideprotected 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种双检锁方式。