公号：码农充电站pro主页：https://codeshellme.github.io
当我们需要使得某个类只能有一个实例时，可以使用单例模式。
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
单例模式的实现需要三个必要的条件：
单例类的构造函数必须是私有的，这样才能将类的创建权控制在类的内部，从而使得类的外部不能创建类的实例。单例类通过一个私有的静态变量来存储其唯一实例。单例类通过提供一个公开的静态方法，使得外部使用者可以访问类的唯一实例。注意：因为单例类的构造函数是私有的，所以单例类不能被继承。
另外，实现单例类时，还需要考虑三个问题：
创建单例对象时，是否线程安全。单例对象的创建，是否延时加载。获取单例对象时，是否需要加锁（锁会导致低性能）。下面介绍五种实现单例模式的方式。
1，饿汉式饿汉式的单例实现比较简单，其在类加载的时候，静态实例instance 就已创建并初始化好了。
代码如下：
public class Singleton { private static final Singleton instance = new Singleton(); private Singleton () {} public static Singleton getInstance() { return instance; }}饿汉式单例优缺点：
优点：单例对象的创建是线程安全的；获取单例对象时不需要加锁。缺点：单例对象的创建，不是延时加载。一般认为延时加载可以节省内存资源。但是延时加载是不是真正的好，要看实际的应用场景，而不一定所有的应用场景都需要延时加载。
2，懒汉式与饿汉式对应的是懒汉式，懒汉式为了支持延时加载，将对象的创建延迟到了获取对象的时候，但为了线程安全，不得不为获取对象的操作加锁，这就导致了低性能。
并且这把锁只有在第一次创建对象时有用，而之后每次获取对象，这把锁都是一个累赘（双重检测对此进行了改进）。
代码如下：
public class Singleton { private static final Singleton instance; private Singleton () {} public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; }}懒汉式单例优缺点：
优点：对象的创建是线程安全的。支持延时加载。缺点：获取对象的操作被加上了锁，影响了并发度。如果单例对象需要频繁使用，那这个缺点就是无法接受的。如果单例对象不需要频繁使用，那这个缺点也无伤大雅。3，双重检测饿汉式和懒汉式的单例都有缺点，双重检测的实现方式解决了这两者的缺点。
双重检测将懒汉式中的 synchronized 方法改成了 synchronized 代码块。如下：
public class Singleton { private static Singleton instance; private Singleton () {} public static Singleton getInstance() { if (instance == null) { synchronized(Singleton.class) { // 注意这里是类级别的锁 if (instance == null) { // 这里的检测避免多线程并发时多次创建对象 instance = new Singleton(); } } } return instance; }}这种实现方式在 Java 1.4 及更早的版本中有些问题，就是指令重排序，可能会导致 Singleton 对象被 new 出来，并且赋值给 instance 之后，还没来得及初始化，就被另一个线程使用了。
要解决这个问题，需要给 instance 成员变量加上 volatile 关键字，从而禁止指令重排序。
而高版本的 Java 已在 JDK 内部解决了这个问题，所以高版本的 Java 不需要关注这个问题。
双重检测单例优点：
对象的创建是线程安全的。支持延时加载。获取对象时不需要加锁。4，静态内部类用静态内部类的方式实现单例类，利用了Java 静态内部类的特性：
Java 加载外部类的时候，不会创建内部类的实例，只有在外部类使用到内部类的时候才会创建内部类实例。代码如下：
public class Singleton { private Singleton () {} private static class SingletonInner { private static final Singleton instance = new Singleton(); } public static Singleton getInstance() { return SingletonInner.instance; }}SingletonInner 是一个静态内部类，当外部类 Singleton 被加载的时候，并不会创建 SingletonInner 实例对象。
只有当调用 getInstance() 方法时，SingletonInner 才会被加载，这个时候才会创建 instance。instance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。
静态内部类单例优点：
对象的创建是线程安全的。支持延时加载。获取对象时不需要加锁。5，枚举用枚举来实现单例，是最简单的方式。这种实现方式通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。
public enum Singleton { INSTANCE; // 该对象全局唯一}6，多例模式上面介绍了5 种单例模式的实现方式，下面作为对单例模式的扩展，再来介绍一下多例模式以及线程间唯一的单例模式。先来看下多例模式。
单例模式是指，一个类只能创建一个对象。那么多例模式就是，一个类可以创建多个对象，但是对象个数可以控制。
对于多例模式，我们可以将类的实例都编上号，然后将实例存放在一个 Map 中。
代码如下：
public class MultiInstance { // 实例编号 private long instanceNum; // 用于存放实例 private static final Map ins = new HashMap(); static { // 存放 3 个实例 ins.put(1L, new MultiInstance(1)); ins.put(2L, new MultiInstance(2)); ins.put(3L, new MultiInstance(3)); } private MultiInstance(long n) { this.instanceNum = n; } public MultiInstance getInstance(long n) { return ins.get(n); }}实际上，Java 中的枚举就是一个“天然”的多例模式，其中的每一项代表一个实例，如下：
public enum MultiInstance { ONE, TWO, THREE;}7，线程唯一的单例一般情况下，我们所说的单例的作用范围是进程唯一的，就是在一个进程范围内，一个类只允许创建一个对象，进程内的多个线程之间也是共享同一个实例。
实际上，在Java 中，每个类加载器都定义了一个命名空间。所以我们这里实现的单例是依赖类加载器的，也就是在同一个类加载器中，我们实现的单例就是真正的单例模式。否则如果有多个类加载器，就会有多个单例出现了。一个解决办法是：自行指定类加载器，并且指定同一个类加载器。
那么线程唯一的单例就是，一个实例只能被一个线程拥有，一个进程内的多个线程拥有不同的类实例。
我们同样可以用 Map 来实现，代码如下：
public class ThreadSingleton { private static final ConcurrentHashMap instances = new ConcurrentHashMap(); private ThreadSingleton() {} public static ThreadSingleton getInstance() { Long id = Thread.currentThread().getId(); instances.putIfAbsent(id, new ThreadSingleton()); return instances.get(id); }}8，使用场景单例模式可以用来管理一些共享资源，比如数据库连接池，线程池；解决资源冲突问题，比如日志打印。节省内存空间，比如配置信息类。
（本节完。）