单例模式

定义

一个类只允许创建唯一一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。

如何实现一个单例？

概括起来，要实现一个单例，我们需要关注的点无外乎下面几个：

• 构造函数需要是 private 访问权限的，这样才能避免外部通过 new 创建实例；
• 考虑对象创建时的线程安全问题；
• 考虑是否支持延迟加载；
• 考虑 getInstance() 性能是否高（是否加锁）。

单例设计模式的方式

1. 饿汉式
2. 懒汉式
3. 双重检查
4. 静态内部类
5. 枚举

1. 饿汉式

1.1 饿汉式（静态变量）

package com.evan.singleton;

/**
 * @Description 饿汉模式
 * 类加载到内存后，就实例化一个单例，JVM保证了线程安全
 * 优点：简单实用
 * 缺点：不管用到与否，类装载时就完成实例化（话说你不用你加载干啥）)
 * @ClassName Mgr01
 * @Author Evan
 * @date 2019.11.24 10:55
 */
public class Mgr01 {

    private static final Mgr01 instance = new Mgr01();

    private Mgr01() {
    }

    public static Mgr01 getInstance() {
        return instance;
    }

}

test

@Test
public void testMgr01() {
    Mgr01 instance = Mgr01.getInstance();
    Mgr01 instance1 = Mgr01.getInstance();

    System.out.println(instance == instance1);
}

饿汉式（静态变量） 小结

1. 优点：这种写法简单，就是在类加载的时候就完成实例化。避免了线程同步问题
2. 缺点：在类装载的时候就完成了实例化，没有达到lazy loading的效果。如果从始到终都没有使用这实例，则会造成内存的浪费
3. 这种方式基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类加载的原因有很多种，因此不能确定有其他方式（或者其他的静态方法）导致类装载，这时候初始换instance就没有达到lazy loading 的效果
4. 结论：这种单例模式可用，可能造成内存浪费。

有人觉得这种实现方式不好，因为不支持延迟加载，如果实例占用资源多（比如占用内存多）或初始化耗时长（比如需要加载各种配置文件），提前初始化实例是一种浪费资源的行为。最好的方法应该在用到的时候再去初始化。不过，也有人并不认同这样的观点。

如果初始化耗时长，那我们最好不要等到真正要用它的时候，才去执行这个耗时长的初始化过程，这会影响到系统的性能（比如，在响应客户端接口请求的时候，做这个初始化操作，会导致此请求的响应时间变长，甚至超时）。采用饿汉式实现方式，将耗时的初始化操作，提前到程序启动的时候完成，这样就能避免在程序运行的时候，再去初始化导致的性能问题。

如果实例占用资源多，按照 fail-fast 的设计原则（有问题及早暴露），那我们也希望在程序启动时就将这个实例初始化好。如果资源不够，就会在程序启动的时候触发报错（比如 Java 中的 PermGen Space OOM），我们可以立即去修复。这样也能避免在程序运行一段时间后，突然因为初始化这个实例占用资源过多，导致系统崩溃，影响系统的可用性。

其实在日常开发过程中，该方式的实现的单例模式挺常用的,因为不用考虑线程安全问题。

1.2 饿汉式（静态代码块）

package com.evan.singleton;

/**
 * @Description
 * @ClassName Mgr02
 * @Author Evan
 * @date 2019.11.24 11:11
 */
public class Mgr02 {
    private static Mgr02 Instance;

    static {
        Instance = new Mgr02();
    }

    private Mgr02() {
    }

    public static Mgr02 getInstance() {
        return Instance;
    }

test

@Test
public void testMgr02() {
    Mgr01 instance = Mgr02.getInstance();
    Mgr01 instance1 = Mgr02.getInstance();

    System.out.println(instance == instance1);
}

1.2.1 饿汉式（静态代码块）小结

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行了静态代码块中的代码，初始化类的实例。优缺点和上面的一样

2. 饿汉式

2.1 懒汉式(线程不安全)

不知道为啥就是记不住饿汉和懒汉，就像我记不住东西南北一样。所以一般都是说lazy 加载和正常加载。

package com.evan.singleton;

/**
 * @Description lazy loading
 * 虽然达到了目的，但是带来了线程问题
 * @ClassName Mgr03
 * @Author Evan
 * @date 2019.11.24 11:20
 */
public class Mgr03 {
    private static Mgr03 Instance;

    private Mgr03() {
    }

    public static Mgr03 getInstance() {

        if (Instance == null) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Instance = new Mgr03();
        }
        return Instance;
    }
}

test

@Test
public void testMgr03() {
    for (int i = 0; i < 100; i++) {
        new Thread(
                () -> {
                    System.out.println(Mgr03.getInstance().hashCode());
                }
        ).start();
    }
}

// 线程A getInstance()  发现没有实例于是执行Instance = new Mgr03();转载资源ing
// 线程B getInstance()  发现没有实例于是执行Instance = new Mgr03();
// 这个时候内存中就会有两个不同的实例

2.1.1 懒汉式(线程不安全)小结

1. 起到了Lazy Loading的效果，但是只能在单线程下使用
2. 如果在多线程下，一个线程进入了 if (Instance == null) 判断语句块，还未执行下面的操作。另一个线程也通过了这个判断语句，这时便会产生多个实例，所以在多线程环境下不可使用这种方式
3. 结论：在实际开发中，不要使用这种方式

2.2 懒汉式(线程安全)

/**
 * @Description lazy loading
 * 虽然达到了目的，但是带来了线程问题
 * 可以通过synchronized 解决，但是性能也会下降
 * @Author Evan
 * @date 2019.11.24 11:37
 */
public class Mgr04 {
    private static Mgr04 Instance;

    private Mgr04() {
    }

    public static synchronized Mgr04 getInstance() {

        if (Instance == null) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Instance = new Mgr04();
        }
        return Instance;
    }
}

test

@Test
public void testMgr04() {
    for (int i = 0; i < 100; i++) {
        new Thread(
                () -> {
                    System.out.println(Mgr04.getInstance().hashCode());
                }
        ).start();
    }
}

2.2.1 懒汉式(线程安全)小结

1. 解决了线程安全问题
2. 效率太低，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低
3. 结论：在实际开发中，不推荐这种方式

2.3 懒汉式(线程安全，同步代码块)

package com.evan.singleton;

/**
 * @Description
 * @ClassName Mgr05
 * @Author Evan
 * @date 2019.11.24 11:41
 */
public class Mgr05 {
    private static volatile Mgr05 Instance;

    private Mgr05() {
    }

    public static synchronized Mgr05 getInstance() {

        if (Instance == null) {
            // 通过减小同步代码块的方式提高效率，其实是不可行的
            // 线程A getInstance()  发现没有实例于是执行Instance = new Mgr03();
            // 线程B getInstance()  发现没有实例于是执行Instance = new Mgr03(); 线程B得到synchronized (Mgr05.class) {}代码块的锁且实例化
            // 线程B 释放锁后，线程A 得到锁且继续执行
            // 这个时候内存中就会有两个不同的实例
            synchronized (Mgr05.class) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Instance = new Mgr05();
            }
        }

        return Instance;
    }
   
   }

test

@Test
public void testMgr05() {
    for (int i = 0; i < 100; i++) {
        new Thread(
                () -> {
                    System.out.println(Mgr05.getInstance().hashCode());
                }
        ).start();
    }
}

懒汉式的缺点也很明显，我们给 getInstance() 这个方法加了一把大锁（synchronzed），导致这个函数的并发度很低。量化一下的话，并发度是 1，也就相当于串行操作了。而这个函数是在单例使用期间，一直会被调用。如果这个单例类偶尔会被用到，那这种实现方式还可以接受。但是，如果频繁地用到，那频繁加锁、释放锁及并发度低等问题，会导致性能瓶颈，这种实现方式就不可取了。

3 双重检查

饿汉式不支持延迟加载，懒汉式有性能问题，不支持高并发。那我们再来看一种既支持延迟加载、又支持高并发的单例实现方式，也就是双重检测实现方式。

package com.evan.singleton;

/**
 * @Description
 * @ClassName Mgr06
 * @Author Evan
 * @date 2019.11.24 11:50
 */
public class Mgr06 {

    private static volatile Mgr06 Instance;

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        // 双重检查
        if (Instance == null) {
            // 此处为类级别的锁
            synchronized (Mgr06.class) {
                if (Instance == null) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Instance = new Mgr06();
                }
            }
        }

        return Instance;
    }

}

test

@Test
public void testMgr06() {
    for (int i = 0; i < 100; i++) {
        new Thread(
                () -> {
                    System.out.println(Mgr06.getInstance().hashCode());
                }
        ).start();
    }
}

3.1 双重检查的小结

1. Double-check 概念是多线程开发中经常用到的，如代码中所示，我们进行了两次if (Instance == null)检查，这样就可以保证线程安全了
2. 这样，实例化代码只用执行一次，后面再次访问时，判断if (Instance == null)，直接return实例化对象，也避免的反复进行方法同步
3. 线程安全：延迟加载，效率较高
4. 结论：在实际开发中，推荐使用这种单例设计模式

网上有人说，这种实现方式有些问题。因为指令重排序，可能会导致 Mgr06 对象被 new 出来，并且赋值给 instance 之后，还没来得及初始化（执行构造函数中的代码逻辑），就被另一个线程使用了。

要解决这个问题，我们需要给 instance 成员变量加上 volatile 关键字，禁止指令重排序才行。实际上，只有很低版本的 Java 才会有这个问题。我们现在用的高版本的 Java 已经在 JDK 内部实现中解决了这个问题（解决的方法很简单，只要把对象 new 操作和初始化操作设计为原子操作，就自然能禁止重排序）。

4 静态内部类

我们再来看一种比双重检测更加简单的实现方法，那就是利用 Java 的静态内部类。它有点类似饿汉式，但又能做到了延迟加载。具体是怎么做到的呢？我们先来看它的代码实现。

package com.evan.singleton;

/**
 * @Description 静态内部类方式
 * JVM保证单例 JVM 加载一个class的时候只加载一次
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 * @ClassName Mgr07
 * @Author Evan
 * @date 2019.11.24 11:53
 */
public class Mgr07 {

    private Mgr07() {
    }

    public static class Mgr07Holder {
        private final static Mgr07 Instance = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.Instance;
    }
}

test

@Test
public void testMgr07() {
    for (int i = 0; i < 100; i++) {
        new Thread(
                () -> {
                    System.out.println(Mgr07.getInstance().hashCode());
                }
        ).start();
    }
}

Mgr07Holder 是一个静态内部类，当外部类 Mgr07 被加载的时候，并不会创建 Mgr07Holder 实例对象。只有当调用 getInstance() 方法时，Mgr07Holder 才会被加载，这个时候才会创建 instance。insance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。所以，这种实现方法既保证了线程安全，又能做到延迟加载。

4.1 静态内部类小结

1. 这种方式采用了类转载的机制来保证初始化实例是只有一个线程
2. 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getIntstance方法，才会被装载Mgr07Holder类，从而完成Mgr07的实例化.
3. 类的静态属性只会在第一次加载的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的
4. 优点：避免了线程的不安全，利用静态内部类特点实现延迟加载，效率高

如果不明白，可以学习下类的实例在什么时候创建，类的静态代码块、静态属性、静态方法、构造方法的创建顺序。以及访问类的静态变量是否会创建类的实例。

5 枚举

基于枚举类型的单例实现。这种实现方式通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。具体的代码如下所示：

package com.evan.singleton;

/**
 * @Description 不仅可以坚决线程问题，且可以防止反序列化
 * @ClassName Mgr08
 * @Author Evan
 * @date 2019.11.24 12:02
 */
public enum Mgr08 {

    INSTANCE;

}

test

@Test
public void testMgr08() {
        for (int i = 0; i < 100; i++) {
            new Thread(
                    () -> {
                        System.out.println(Mgr08.INSTANCE.hashCode());
                    }
            ).start();
        }
    }
}

5.1 枚举小结

不仅可以坚决线程问题，且可以防止反序列化

6 单例模式小结

1. 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能
2. 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new(构造方法私有化了，new 也没法用呀)
3. 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级 对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session 工厂等)

7. 如何实现一个集群环境下的分布式单例模式？

首先，我们重新看一下单例的定义：“一个类只允许创建唯一一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。”

定义中提到，“一个类只允许创建唯一一个对象”。那对象的唯一性的作用范围是什么呢？是指线程内只允许创建一个对象，还是指进程内只允许创建一个对象？答案是后者，也就是说，单例模式创建的对象是进程唯一的。

7.1 如何实现线程唯一的单例？

单例类对象是进程唯一的，一个进程只能有一个单例对象。那如何实现一个线程唯一的单例呢？

“进程唯一”指的是进程内唯一，进程间不唯一。类比一下，“线程唯一”指的是线程内唯一，线程间可以不唯一。实际上，“进程唯一”还代表了线程内、线程间都唯一，这也是“进程唯一”和“线程唯一”的区别之处。

假设 IdGenerator 是一个线程唯一的单例类。在线程 A 内，我们可以创建一个单例对象 a。因为线程内唯一，在线程 A 内就不能再创建新的 IdGenerator 对象了，而线程间可以不唯一，所以，在另外一个线程 B 内，我们还可以重新创建一个新的单例对象 b。

尽管概念理解起来比较复杂，但线程唯一单例的代码实现很简单，如下所示。在代码中，我们通过一个 HashMap 来存储对象，其中 key 是线程 ID，value 是对象。这样我们就可以做到，不同的线程对应不同的对象，同一个线程只能对应一个对象。实际上，Java 语言本身提供了 ThreadLocal 工具类，可以更加轻松地实现线程唯一单例。不过，ThreadLocal 底层实现原理也是基于下面代码中所示的 HashMap。

public class IdGenerator {
  private AtomicLong id = new AtomicLong(0);
  private static final ConcurrentHashMap<Long, IdGenerator> instances = new ConcurrentHashMap<>();
  private IdGenerator() {}
  public static IdGenerator getInstance() {
    Long currentThreadId = Thread.currentThread().getId();
    instances.putIfAbsent(currentThreadId, new IdGenerator());
    return instances.get(currentThreadId);
  }
  public long getId() {
    return id.incrementAndGet();
  }
}

7.2 如何实现集群环境下的单例？

我们再来看下，“集群唯一”的单例。

首先，我们还是先来解释一下，什么是“集群唯一”的单例。

我们还是将它跟“进程唯一”“线程唯一”做个对比。“进程唯一”指的是进程内唯一、进程间不唯一。“线程唯一”指的是线程内唯一、线程间不唯一。集群相当于多个进程构成的一个集合， “集群唯一”就相当于是进程内唯一、进程间也唯一。也就是说，不同的进程间共享同一个对象，不能创建同一个类的多个对象。

我们知道，经典的单例模式是进程内唯一的，那如何实现一个进程间也唯一的单例呢？如果严格按照不同的进程间共享同一个对象来实现，那集群唯一的单例实现起来就有点难度了。

具体来说，我们需要把这个单例对象序列化并存储到外部共享存储区（比如文件）。进程在使用这个单例对象的时候，需要先从外部共享存储区中将它读取到内存，并反序列化成对象，然后再使用，使用完成之后还需要再存储回外部共享存储区。

为了保证任何时刻，在进程间都只有一份对象存在，一个进程在获取到对象之后，需要对对象加锁，避免其他进程再将其获取。在进程使用完这个对象之后，还需要显式地将对象从内存中删除，并且释放对对象的加锁。

按照这个思路，我用伪代码实现了一下这个过程，具体如下所示：

public class IdGenerator {
  private AtomicLong id = new AtomicLong(0);
  private static IdGenerator instance;
  private static SharedObjectStorage storage = FileSharedObjectStorage(/*入参省略，比如文件地址*/);
  private static DistributedLock lock = new DistributedLock();
  
  private IdGenerator() {}
  public synchronized static IdGenerator getInstance() 
    if (instance == null) {
      lock.lock();
      instance = storage.load(IdGenerator.class);
    }
    return instance;
  }
  
  public synchroinzed void freeInstance() {
    storage.save(this, IdGeneator.class);
    instance = null; //释放对象
    lock.unlock();
  }
  
  public long getId() { 
    return id.incrementAndGet();
  }
}
// IdGenerator使用举例
IdGenerator idGeneator = IdGenerator.getInstance();
long id = idGenerator.getId();
IdGenerator.freeInstance();

还有一种思路就是将该功能做成一个微服务，提供接口对外提供服务。