1.单例模式（Singleton Pattern)

        单例模式是Java中最简单的设计模式之一。属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

目的：保证一个类仅有一个实例，并提供一个访问它的全局访问点

说明：

1. 单例类只能有一个实例，即在单例类中创建该类对象，即对该对象进行私有化。

2. 构造方法私有化，即保证不能通过 new 关键字来创建对象，将创建对象的任务交给该单例类自己实现。

3. 对外提供一个获取该单例类的对象的公共静态访问方法。

优点：

1. 在内存中只有一个实例，减少了内存开销

2. 避免对资源的多重占用

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么实例化

单例模式的几种实现方式：

• 懒汉式，非线程安全

package com.acmen.singleton_pattern;
 ​
 /**
  * 这是懒汉式的单例模式，即要用到这个单例对象的时候才去实例化这个单例对象，但是是非线程安全的
  */
 public class LazySingleton {
 ​
     //定义一个懒汉式单例
     private static LazySingleton lazySingleton = null;
 ​
     //构造方法私有化
     private LazySingleton(){}
 ​
     //对外提供一个公共的获取单例对象的接口方法
     public static LazySingleton getInstance(){
         if (lazySingleton == null){
             lazySingleton = new LazySingleton();
         }
         return lazySingleton;
     }
 }

• 懒汉式，线程安全

  使用了synchronized关键字。

 package com.acmen.singleton_pattern;
 ​
 /**
  * 懒汉式的单例模式，即要用到这个单例对象的时候才去实例化这个单例对象。
  * 使用了synchronized关键字，所以它是线程安全的
  */
 public class LazySingleton {
 ​
     //定义一个懒汉式单例
     private static LazySingleton lazySingleton = null;
 ​
     //构造方法私有化
     private LazySingleton(){}
 ​
     //对外提供一个公共的获取单例对象的接口方法，使用 synchronized 关键字确保线程安全
     public static synchronized LazySingleton getInstance(){
         if (lazySingleton == null){
             lazySingleton = new LazySingleton();
         }
         return lazySingleton;
     }
 }

• 饿汉式

  • 优点

    • 没有加锁，执行效率高

  • 缺点

    • 类加载时就初始化，浪费内存

    • 没有达到懒加载的效果

 package com.acmen.singleton_pattern;
 ​
 /**
  * 这是饿汉式的单例模式，将其单例类创建对象，在调用对外方法时返回该单例对象即可
  * 这是线程安全的单例模式
  */
 public class HungrySingleton {
 ​
     //定义一个饿汉式的实例
     private static HungrySingleton hungrySingleton = new HungrySingleton();
 ​
     //构造方法私有化
     private HungrySingleton(){
 ​
     }
     
     //对外提供一个公共的获取单例对象的方法
     public static HungrySingleton getInstance(){
         return hungrySingleton;
     }
 }

• 双检锁/双重校验锁（DCL，即double-checked locking）

  采用双锁机制，安全且在多线程情况下能保持高性能。

  volatile关键字的作用：

  1. 保存内存可见性：所有线程都能看到共享内存的最新状态，volatile关键字修饰的变量看到的随时是自己的最新值。

  2. 防止指令重排：volatile关键字通过内存屏障来防止指令被重排序。（dclSingleton = new DCLSingleton()这个操作并不是一个原子操作，会导致指令重排

 package com.acmen.singleton_pattern;
 ​
 public class DCLSingleton {
     //定义一个双重锁单例类的实例对象，volatile关键字常用于保持内存可见性和防止指令重排序。
     private volatile static DCLSingleton dclSingleton;
     
     //构造方法私有化
     private DCLSingleton(){
 ​
     }
 ​
     //提供对外访问的公共静态方法
     public static DCLSingleton getInstance(){
         synchronized (DCLSingleton.class){
             if (dclSingleton == null){
                 dclSingleton = new DCLSingleton();
             }
         }
         return dclSingleton;
     }
 }

• 登记式/静态内部类

这种方式同样利用了 classloader 机制来保证初始化单例类对象时只有一个线程，它跟饿汉式不同的是：饿汉式只要单例类被装载了，那么 单例类对象就会被实例化（没有达到 lazy loading 效果），而这种方式是单例类被装载了，单例类对象不一定被初始化。因为SingleHolder没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化单例类对象REGISTER_SINGLETON。

能达到双检锁方式一样的功效，但只适用于静态域的情况，而双检锁方式可以在实例域需要延迟初始化时使用。

 package com.acmen.singleton_pattern;
 ​
 public class RegisterSingleton {
     
     //定义一个静态内部类
     private static class SingleHolder{
         //创建一个外部类的静态 final 对象
         private static final RegisterSingleton REGISTER_SINGLETON = new RegisterSingleton();
     }
 ​
     //构造方法私有化
     private RegisterSingleton(){
 ​
     }
 ​
     //提供对外访问的 public 方法
     public static final RegisterSingleton getInstance(){
         return SingleHolder.REGISTER_SINGLETON;
     }
 ​
 }

• 枚举

这种方式还没有被广泛使用，但是是实现单例模式的最佳方法。它更简洁，自动支持反序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法。

 package com.acmen.singleton_pattern;
 ​
 public enum EnumSingleton {
     ENUM_SINGLETON;
     public void whateverMethod(){
         System.out.println("这是枚举类型的单例模式");
     }
 }
使用方式：

 public static void main(String[] args) {
         EnumSingleton singleton = EnumSingleton.ENUM_SINGLETON;
         singleton.whateverMethod();
 }

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。