1 单例模式介绍
单例模式（Singleton Pattern）是Java中最为基础的设计模式。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
1.1 场景
目的：控制实例数目，节省系统资源；
适用：若一个全局使用的类频繁地创建与销毁，单例模式可以证一个类仅有一个实例，并提供一个访问它的全局访问点。
要求生产唯一序列号；
WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来；
创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
优点：
如此内存中只有一个实例，减少了内存的开销；
避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
注：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种双检锁方式。
