单例模式--设计模式

创建型设计模式，能确保一个类只有一个实例，并提供对该实例的全局访问点

例子

// 单例类
class Singleton {
    // 静态变量用于保存唯一实例
    private static Singleton instance;

    // 私有构造方法，防止外部实例化
    private Singleton() {
    }

    // 静态方法获取实例
    public static Singleton getInstance() {
        // 如果实例不存在，则创建一个新实例
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    // 其他业务方法
    public void doSomething() {
        System.out.println("Singleton is doing something...");
    }
}

public class Main {
    public static void main(String[] args) {
        // 获取单例实例
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        // 验证两个实例是否相同
        System.out.println(singleton1 == singleton2);  // 输出: true

        // 调用单例实例的方法
        singleton1.doSomething();  // 输出: Singleton is doing something...
    }
}

Singleton类是一个单例类，他的构造方法是私有的，外部无法直接实例化该类。

通过静态方法getInstance（）返回类的唯一实例

在该方法中，如果实例不存在，则创建一个新实例并赋值给静态变量instance，否则直接返回已有的实例

那么接下来有个问题：为什么有私有构造方法，就能防止外部实例化？

因为构造方法被声明为private，只能在类内部访问，不能从外部进行实例化，意味着其他类不能通过new关键字来创建该类的实例。

class MyClass {
    private MyClass() {
        // 私有构造方法
    }

    public static MyClass getInstance() {
        return new MyClass();
    }
}

public class Main {
    public static void main(String[] args) {
        // 由于构造方法是私有的，无法直接实例化
        // MyClass obj = new MyClass();  // 编译错误

        // 通过静态方法获取实例
        MyClass obj = MyClass.getInstance();
    }
}

第二个问题：饿汉和懒汉又是什么意思？

饿汉和懒汉式单例模式的两种实现方式。

1.饿汉模式

• 在类加载时就创建实例，并且始终保持一个全局的唯一实例。
• 饿汉模式的特点是线程安全，因为实例在类加载阶段就被创建了，其他线程访问时直接获取已存在的实例。
• 缺点是当应用程序启动时，不论是否使用该实例，都会进行对象的创建，可能会造成资源浪费。

class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {
        // 私有构造方法
    }

    public static Singleton getInstance() {
        return instance;
    }
}

2.懒汉模式

• 在第一次使用时才会创建实例。
• 懒汉模式的特点是延迟加载，只有在需要时才会创建实例。
• 缺点是不是线程安全的，如果多个线程同时访问，可能会创建多个实例。

  class Singleton {
      private static Singleton instance;
  
      private Singleton() {
          // 私有构造方法
      }
  
      public static synchronized Singleton getInstance() {
          if (instance == null) {
              instance = new Singleton();
          }
          return instance;
      }
  }
  

  第三个问题：如何解决线程安全问题呢

1.为了保证线程安全，我们使用了 synchronized 关键字来确保在多线程环境下只会有一个线程创建实例

class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // 私有构造方法
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2.使用synchronized关键字修饰整个方法会导致性能下降，因为每次调用getInstance都需要获得锁，即使实例已经被创建，Java5之后引入了volatile关键字也可以实现线程安全的懒汉模式，且性能更好。

class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // 私有构造方法
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

也可以使用双重检查锁定（Double-Checked Locking）或静态内部类的方法保证线程安全

3.双重检查锁定

• 双重检查锁定是指先检查实例是否已经创建，如果没有创建才进行同步块，然后再次检查实例是否已经创建，这样可以减少进入同步块的次数，提高性能。
• 双重检查锁定需要将实例变量声明为 volatile，确保可见性和禁止指令重排序

class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // 私有构造方法
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

首先检查视力是否为空，如果为空，则进入同步块，在同步块内再检查实例是否为空，避免了多个线程同时通过了第一个检查而同时创建了实例。

4.静态内部类

• 静态内部类只会在第一次使用时被加载，且只会被加载一次，所以可以保证实例的唯一性。
• 静态内部类的加载是线程安全的，因此可以避免线程安全问题。

class Singleton {
    private Singleton() {
        // 私有构造方法
    }

    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

当调用getInstance()方法时，会首先加载SingletonHolder类，由于静态内部类的加载时延迟的，只有第一次使用SingletonHolder.instance时才会加载，从而实现了懒加载。