本文共 2686 字，大约阅读时间需要 8 分钟。

学习总结

1. 单列的核心就是这东西，我们只想要一份，无论多少人调用它。都是调这个实例。
2. 懒汉：调用时才创建实例，能省点是点。
3. 饿汉：初始化时直接生成实例，要用时直接调，无需等待。当然如果一直都没调它，那就活活浪费着。。。
4. Java实现中考虑线程安全问题，衍生出了8种方式。其实好多是凑数的没啥意义。
5. 线程安全问题来自于懒汉模式运行时动态创建实例，多线程自然就会有撞车风险。饿汉模式就不存在线程安全问题了。

应用场景

1. 我们经常在工具类中使用单列。

代码示例

饿汉 hungry

1. 经典饿汉模式

天然线程安全。

public class Singleton1 {
       private static Singleton1 instance = new Singleton1();    private Singleton1 (){
   }    public static Singleton1 getInstance() {
           return instance;    }    public void show(){
           System.out.println("饿汉模式");    }}

2. 枚举实现

饿汉。用枚举实现，Effective Java 作者 Josh Bloch 提倡的方式。

public enum Singleton2Enum {
       INSTANCE;    public void show(){
           System.out.println("饿汉枚举实现");    }}

3. 客户端

public class SingletonHungryDemo {
       public static void main(String[] args) {
           // 经典饿汉        Singleton1.getInstance().show();        // 枚举类        Singleton2Enum.INSTANCE.show();    }}

懒汉 lazy

1. 直接加 synchronized

懒汉：线程安全。synchronized 实现线程安全，但效率低。去掉能提高效率，但会线程不安全。

public class Singleton1ThreadSafe {
       private static Singleton1ThreadSafe instance;    private Singleton1ThreadSafe(){
   }    public static synchronized Singleton1ThreadSafe getInstance() {
           if (instance == null) {
               instance = new Singleton1ThreadSafe();        }        return instance;    }        public void show(){
           System.out.println("懒汉：线程安全");    }}

2. 静态内部类

懒汉：静态内部类。利用静态内部类显示调用时才会加载的特性实现懒加载。

public class Singleton2LazyStaticInnerClass {
       private static class SingletonHolder {
           private static final Singleton2LazyStaticInnerClass INSTANCE = new Singleton2LazyStaticInnerClass();    }    private Singleton2LazyStaticInnerClass(){
   }    public static final Singleton2LazyStaticInnerClass getInstance() {
           return SingletonHolder.INSTANCE;    }    public void show(){
           System.out.println("懒汉：静态内部类。利用静态内部类显示调用时才会加载的特性实现懒加载。");    }}

3. 双重检查锁

懒汉：双重检查锁。在方法内部进行了加锁操作，同时使用 volatile 修饰 instance，防止 Java 指令重排，确保当变量 instance 被初始化成实例时，多个线程正确的处理 instance 变量。

public class Singleton3DoubleCheckLock {
       private volatile static Singleton3DoubleCheckLock singleton;    private Singleton3DoubleCheckLock (){
   }        public static Singleton3DoubleCheckLock getInstance() {
           if (singleton == null) {
               synchronized (Singleton3DoubleCheckLock.class) {
                   if (singleton == null) {
                       singleton = new Singleton3DoubleCheckLock();                }            }        }        return singleton;    }        public void show(){
           System.out.println("懒汉：双重检查锁");    }}

参考资料

转载地址：https://jerryjin.blog.csdn.net/article/details/115910599 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！