单例模式详解

一、 概述

1.1 定义

确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

1.2 使用场景

确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源;或者某种类型的对象应该有且只有一个。

eg:创建一个对象需要消耗的资源过多,如访问IO和数据库资源。

1.3 关键点

  • 构造函数不对外开放,一般为 private ;
  • 通过一个静态方法或者枚举返回单例类对象;
  • 确保单例类的对象有且只有一个,尤其是在 多线程 环境下;
  • 确保单例类对象在反序列化时不会重新构建对象。

二、实现方式

2.1 懒汉模式

声明一个静态对象,并且在用户第一次调用 getInstance 时进行初始化。

2.1.1 分析

  • synchronized 关键字用于在多线程情况下保证单例对象唯一性

  • 优点:单例只有在使用时才会被实例化,在一定程度上节约了资源

  • 缺点:

    • 每一次加载时需要及时进行实例化,响应速度稍慢
    • 每次调用 getInstance() 都进行同步,造成不必要的同步开销
  • 一般不建议使用

2.1.2 源码

public class Singleton {
    private static Singleton instance;

    private Singleton() {

    }

    public static synchronized Singleton getInstance() {
        if (null == instance) {
            instance = new Singleton();//加载时进行实例化
        }
        return instance;
    }
}

2.2 饿汉模式

声明静态对象时就已经初始化。

2.2.1 分析

  • 静态对象在声明的时候就已经初始化,从而保证了单例对象唯一性

  • 优点: 每次调用 getInstance() 直接取出静态对象,不需要同步锁,响应速度快

  • 缺点:初始化声明对象造成了一定资源的闲置浪费

2.2.2 源码

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

    private Singleton() {

    }

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

2.3 Double Check Lock (DCL) 模式

2.3.1 分析

  • 优点:

    • 资源利用率高
    • 既能够在需要时才初始化单例,又能够保证线程安全,且单例对象初始化后调用 getInstance() 不进行同步锁
  • 缺点:

    • 第一次加载时响应稍慢
    • 由于Java内存模型的原因偶尔会失败
      • instance = new Singleton(); 这句代码并不是一个原子操作,由于 Java 编译器允许处理器乱序执行汇编指令以及 JDK1.5 之前的 JVM (Java Memory Model, Java 内存模型) 中Cache、寄存器到主内存回写顺序的规定,该语句转换的汇编指令无法确保顺序执行
      • 在 JDK1.5 之后,具体化了 volatile 关键字,因此可以直接定义成 private volatile static Singleton instance = null; ,就可以保证 instance 对象每次都是从主内存中读取

2.3.2 源码

public class Singleton {
    private volatile static Singleton instance = null;

    private Singleton() {

    }

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

2.4 静态内部类单例模式

2.4.1 分析

强烈推荐使用

  • 优点:

    • 第一次加载 Singleton 类时并不会初始化 instance ,只有在第一次调用 getInstance() 时才会初始化
    • 既能保证线程安全,也能保证单例对象的唯一性,同时也延迟了单例的实例化

2.4.2 源码

public class Singleton {
    private Singleton() {

    }

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

    /**
     * 静态内部类
     */
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }
}

2.5 枚举单例

2.5.1 分析

枚举单例模式最大的优点是写法简单,枚举在 Java 中与普通类是一样的,不仅能够有字段,还能够有自己的方法。最重要的是默认枚举实例的创建时线程安全的,并且在任何情况下它都是一个单例。

在上述的几种单例模式中,反序列化 的时候会出现重新创建对象的情况。

上述示例中如果要杜绝单利对象在被反序列化时重新生成对象,则必须加入如下方法:

private Object readResolve() throws ObjectStreamException {
        return instance;
}

2.5.2 源码

public enum  Singleton {

    INSTANCE;

    public void doSomething() {
        // ... do something
    }

}

2.6 使用容器实现单例模式

2.6.1 分析

在程序初始化的时候,将多种单例类型注入到一个统一的管理类中,在使用时根据 key获取对象对应类型的对象。

这种方式使得我们可以管理多种类型的单例,并且在使用时候可以通过统一的接口进行获取操作,降低了用户的使用成本,也对用户隐藏了具体实现,降低了耦合度。

2.6.2 源码

public class SingletonManager {
    private static Map<String, Object> data = new HashMap<>();

    public SingletonManager() {
    }

    public static void register(String key, Object instance) {
        if (!data.containsKey(key)) {
            data.put(key, instance);
        }
    }

    public static Object get(String key) {
        return data.get(key);
    }
}

三、小结

所有的单例模式核心原理都是将构造函数私有化,并且通过静态方法获取一个唯一的实例。

需要注意的是在获取实例的过程中保证线程安全、防止反序列化导致重新生成实例对象等问题。

具体选择哪种方式实现单例模式还需要结合项目业务逻辑。


发布了166 篇原创文章 · 获赞 15 · 访问量 19万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览