业余做网站郑州网络营销推广

UML图：

• 静态私有变量（即常量）保存单例对象，防止使用过程中重新赋值，破坏单例。
• 私有化构造方法，防止外部创建新的对象，破坏单例。
• 静态公共getInstance方法，作为唯一获取单例对象的入口。

public class Demo1 {public static void main(String[] args) {Singleton singleton1 = new Singleton();Singleton singleton2 = new Singleton();System.out.println(singleton1);System.out.println(singleton2);System.out.println(singleton1 == singleton2);}static class Singleton {public Singleton() {}}
}

1. 饿汉式--最简单有效，唯一的缺陷在于当对象占用空间较大时，可能浪费内存空间。

public class Demo2 {public static void main(String[] args) {Demo2 instance = Demo2.getInstance();Demo2 instance2 = Demo2.getInstance();System.out.println(instance);System.out.println(instance2);System.out.println(instance == instance2);}private static final Demo2 singleton = new Demo2();private Demo2() {}public static Demo2 getInstance() {return singleton;}
}

1. DCL（Double Check Lock）懒汉式

public class Demo3 {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Demo3 instance = Demo3.getInstance();Demo3 instance2 = Demo3.getInstance();System.out.println(instance);System.out.println(instance2);System.out.println(instance == instance2);System.out.println("**************************************");Constructor<Demo3> declaredConstructor = Demo3.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);Demo3 demo3 = declaredConstructor.newInstance();System.out.println(demo3);System.out.println(demo3 == instance);}private static volatile Demo3 SINGLETON;private Demo3() {}public static Demo3 getInstance() {if (SINGLETON == null) {synchronized (Demo3.class) {if (SINGLETON == null) {SINGLETON = new Demo3();}}}return SINGLETON;}
}

1. 静态内部类
   1. 懒加载（Lazy Initialization）：
      1. 实例仅在第一次调用 getInstance() 方法时创建，这意味着如果在整个程序运行过程中，单例并未被实际使用，则不会创建其实例，避免了不必要的内存消耗。
   2. 线程安全（Thread Safety）：
      1. JVM确保了类的静态初始化只会发生一次，并且是线程安全的。静态内部类的实例化过程会被JVM自动处理并确保其原子性，无需程序员显式添加同步锁。

public class Demo4 {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Demo4 instance = Demo4.getInstance();Demo4 instance2 = Demo4.getInstance();System.out.println(instance);System.out.println(instance2);System.out.println(instance == instance2);System.out.println("**************************");Constructor<Demo4> declaredConstructor = Demo4.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);Demo4 demo4 = declaredConstructor.newInstance();System.out.println(demo4);System.out.println(demo4 == instance);}private Demo4() {}public static class InnerClass {private static final Demo4 DEMO4 = new Demo4();}public static Demo4 getInstance() {return InnerClass.DEMO4;}
}

1. 枚举类--最大的优势就是可以防止通过反射创建新对象。初始化时机： 枚举类型的实例是在类加载时由JVM统一初始化的，这个过程是由JVM的类加载机制保障线程安全的。当枚举类型被首次访问时，JVM会确保枚举类的所有实例都被正确地初始化，且这个初始化过程只执行一次，并在全局范围内保持可见。构造函数的私有化： 枚举类型隐式包含了构造函数，并且默认为私有，不允许外部直接实例化。因此，用户无法随意创建新的枚举实例，确保了在整个系统中只能存在预定义的一组实例。JVM的内存模型： 枚举实例一旦被创建，就会存储在JVM方法区的枚举类的常量池中，每个枚举值都是一个不可变的、唯一引用的对象，这就从根本上杜绝了多线程环境下不同线程创建多个实例的可能性。

public enum Demo5 {INSTANCE;public Demo5 getInstance() {return INSTANCE;}public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Demo5 instance = Demo5.INSTANCE.getInstance();Demo5 instance2 = Demo5.INSTANCE.getInstance();System.out.println(instance);System.out.println(instance.hashCode());System.out.println(instance2);System.out.println(instance2.hashCode());System.out.println(instance == instance2);System.out.println("***************************************************");Constructor<?>[] declaredConstructors = Demo5.class.getDeclaredConstructors();for (Constructor<?> declaredConstructor : declaredConstructors) {Object demo5 = declaredConstructor.newInstance();System.out.println(demo5);System.out.println(demo5.hashCode());System.out.println(demo5 == instance);}}
}

大家如果需要视频讲解，可以关注下我的B站：