关键概念

优点：

有些实例，全局只需要一个就够了，使用单例模式就可以避免一个全局使用的类，频繁的创建与销毁，耗费系统资源。

关键概念

1. 一个私有构造函数（确保只能单例类自己创建实例）：

单例类通常会将其构造函数设为私有，以防止外部代码直接实例化对象。

1. 一个私有静态变量（确保只有一个实例）

单例类通常包含一个私有的静态变量，用于保存该类的唯一实例。

1. 一个公有静态函数（给使用者提供调用方法）

单例类提供一个公共的静态方法，用于获取该类的实例。如果实例不存在，则在该方法内部创建实例并返回。

简单来说就是，单例类的构造方法不让其他人修改和使用；并且单例类自己只创建一个实例，这个实例，其他人也无法修改和直接使用；然后单例类提供一个调用方法，想用这个实例，只能调用。这样就确保了全局只创建了一个

实例。

单例模式的6种实现

单例模式6种实现及各实现的优缺点

1、懒汉式（线程不安全）

private static final Singleton instance = new Singleton();

// 私有构造函数 private Singleton() {}

// 公共静态方法，返回实例 public static Singleton getInstance() {

return instance;

} }

说明：

先不创建实例，当第一次被调用时，再创建实例，所以被称为懒汉式。

优点：

延迟了实例化，如果不需要使用该类，就不会被实例化，只有在需要时才创建实例，避免了资源浪费。

缺点：

线程不安全，多线程环境下，如果多个线程同时进入了 if (uniqueInstance == null)，若此时还未实例化，也就是 uniqueInstance == null，那么就会有多个线程执行 uniqueInstance = new Singleton();，就会实例化多个实例；

2、饿汉式（线程安全）

实现：

public class Singleton { // 类加载时就创建实例

private static final Singleton instance = new Singleton();

// 私有构造函数 private Singleton() {}

// 公共静态方法，返回实例 public static Singleton getInstance() {

return instance;

} }

说明：

先不管需不需要使用这个实例，直接先实例化好实例（饿死⻤一样，所以称为饿汉式），然后当需要使用的时候，直接调方法就可以使用了

优点：

提起实例化好了一个实例，避免了线程不安全问题的出现，

会使操作系统的资源浪费。

3、懒汉式（线程安全）

实现：

public class Singleton { private static Singleton uniqueInstance;

private static singleton() {} private static synchronized Sing leton getUinqueInstance() {

if (uniqueInstance == null) { uniqueInstance = new Singleton();

} return uniqueInstance;

} }

说明：

实现和线程不安全的懒汉式几乎一样，唯一不同的点是，在get方法上加了一把锁。如此一来，多个线程访问，每次只有拿到锁的的线程能够进入该方法，避免了多线程不安全问题的出现。

优点：

延迟实例化，节约了资源，并且是线程安全的。

缺点：

虽然解决了线程安全问题，但是性能降低了。因为，即使实例已经实例化了，既后续不会再出现线程安全问题了，但是锁还在，每次还是只能拿到锁的线程进入该方法使线程阻塞，等待时间过长。

4、双重检查锁实现（线程安全）

实现：

public class Singleton { private volatile static Singleton uniqueInstance;

private Singleton() {} //使用双重检查锁定保证线程安全

public static Singleton getUniqueInstance() { if (uniqueInstance == null) {

synchronized (Singleton.class) { if (uniqueInstance == null) {

uniqueInstance = new Singleton();

} }

}

说明：

双重检查锁相当于是改进了线程安全的懒汉式。线程安全的懒汉式的缺点是性能降低了，造成的原因是因为即使实例已经实例化，依然每次都会有锁。

而现在，我们将锁的位置变了，并且多加了一个检查。也就是，先判断实例是否已经存在，若已经存在了，则不会执行判断方法内的有锁方法了。而如果，还没有实例化的时候，多个线程进去了，也没有事，因为里面的方法有

锁，只会让一个线程进入最内层方法并实例化实例。如此一来，最多最多，也就是第一次实例化的时候，会有线程阻塞的情况，后续便不会再有线程阻塞的问题。

为什么使用 volatile 关键字修饰了 uniqueInstance 实例变量？

uniqueInstance = new Singleton();

这段代码执行时分为三步：

1. 为 uniqueInstance 分配内存空间
2. 初始化uniqueInstance
3. 将 uniqueInstance 指向分配的内存地址

正常的执行顺序当然是 1>2>3，但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。

单线程环境时，指令重排并没有什么问题；多线程环境时，会导致有些线程可能会获取到还没初始化的实例。

例如：线程A 只执行了 1 和 3，此时线程B来调用 getUniqueInstance()，发现 uniqueInstance 不为空，便获取 uniqueInstance 实例，但是其实此时的 uniqueInstance 还没有初始化。

解决办法就是加一个 volatile 关键字修饰 uniqueInstance，volatile 会禁止 JVM 的指令重排，就可以保证多线程环境下的安全运行。

优点：

延迟实例化，节约了资源；线程安全；并且相对于线程安全的懒汉式，性能提高了。

缺点：

volatile 关键字，对性能也有一些影响。

5、静态内部类实现（线程安全）

实现：

// 静态内部类持有实例 private static class SingletonHolder {

private static final Singleton instance = new Singleton();

}

// 公共静态方法，返回实例 public static Singleton getInstance() {

return SingletonHolder.instance;

} }

说明：

首先，当外部类 Singleton 被加载时，静态内部类 SingletonHolder 并没有被加载进内存。当调用 getUniqueInstance() 方法时，会运行 return SingletonHolder.INSTANCE;

触发了 SingletonHolder.INSTANCE，此时静态内部类 SingletonHolder 才会被加载进内存，并且初始化 INSTANCE 实例，而且 JVM 会确保 INSTANCE 只被实例化一次。

优点：

延迟实例化，节约了资源，且线程安全，性能也提高了。

6、枚举类实现（线程安全）

实现：

public enum Singleton { INSTANCE;

// 可以添加其他方法和属性 public void doSomething() {

// 实现 }

}

说明：

默认枚举实例的创建就是线程安全的，且在任何情况下都是单例。

优点：

写法简单，线程安全，天然防止反射和反序列化调用。

防止反序列化

序列化：