【设计模式】Singleton 单例模式

所谓单例,就是整个程序有且仅有一个实例。该类负责创建自己的对象,同时确保只有一个对象被创建。

使用单例模式可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收。

特点
  • 类构造器私有
  • 持有自己类型的属性
  • 对外提供获取实例的静态方法
一、应用场景:
  1. 开发项目时候多个功能模块都需要写log。为了把log集中处理,便于分析,log对象可以是单例的。
  2. 有一个配置文件,很多功能模块都会用到其中的一部分,比如模块1用A部分,模块2用B部分。因此该配置文件的对象可以是单例的。
  3. 通用的计算模块,总是被很多模块调用,比如DateUtil工具类,那这个模块可以是单例的。
  4. 在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。
二、五种单例写法:
  1. 懒汉模式
线程不安全 如果此时有两个线程,线程A执行到1处,读取了instance为null,然后cpu就被线程B抢去了,此时,线程A还没有对instance进行实例化。因此,线程B读取instance时仍然为null,于是,它对instance进行实例化了。然后,cpu就被线程A抢去了。此时,线程A由于已经读取了instance的值并且认为它为null,所以,再次对instance进行实例化。所以,线程A和线程B返回的不是同一个实例 ,延迟初始化,严格意义上不是单例模式
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
    if (instance == null) { //1:读取instance的值
    instance = new Singleton(); //2: 实例化instance
    }
    return instance;
  }
}

     2. 饿汉模式

线程安全(类加载时就实例化了一个对象,由于一个类在整个生命周期中只会被加载一次,一次该单例类只会创建一个实例,所以,洗车行那个每次都只能拿到这个唯一的对象,因此,它是线程安全的),比较常用,但容易产生垃圾,因为一开始就初始化
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
    return instance;
}
}

     3. 双重锁模式 (Double Check Lock)

线程安全,延迟初始化。这种方式采用双锁机制,安全且在多线程情况下能保持高性能。
volatile:
  1. 保证可见性。使用 volatile 定义的变量,将会保证对所有线程的可见性。
  2. 禁止指令重排序优化
synchronized 可以保证方法或者代码块在运行时,同一时刻只有一个方法可以进入到临界区,同时它还可以保证共享变量的内存可见性
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
    if (singleton == null) {
        singleton = new Singleton();
    }
    }
}
return singleton;
}
}

双重检查模式,进行了两次的判断, 首先判断变量是否被初始化,没有被初始化,再去获取锁。获取锁之后,再次判断变量是否被初始化。第二次判断目的在于有可能其他线程获取过锁,已经初始化改变量。第二次检查还未通过,才会真正初始化变量。但是,由于jvm存在乱序执行功能,DCL也会出现线程不安全的情况。具体分析如下:

INSTANCE  = new SingleTon();
 
这个步骤,其实在jvm里面的执行分为三步:
  1.在堆内存开辟内存空间。
  2.在堆内存中实例化SingleTon里面的各个参数。
  3.把对象指向堆内存空间。
 
由于jvm存在乱序执行功能,所以可能在2还没执行时就先执行了3,如果此时再被切换到线程B上,由于执行了3,INSTANCE 已经非空了,会被直接拿出来用,这样的话,就会出现异常。这个就是著名的 DCL失效问题
解决办法:
由于 volatile 禁止对象创建时指令之间重排序,所以其他线程不会访问到一个未初始化的对象,从而保证安全性。
 
    4. 静态内部类单例模式
public class SingleTon{
  private SingleTon(){}
  private static class SingleTonHoler{
     private static SingleTon INSTANCE = new SingleTon();
}
  public static SingleTon getInstance(){
    return SingleTonHoler.INSTANCE;
  }
}
静态内部类的优点是:外部类加载时并不需要立即加载内部类,内部类不被加载则不去初始化INSTANCE,故而不占内存。即当SingleTon第一次被加载时,并不需要去加载SingleTonHoler,只有当getInstance()方法第一次被调用时,才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类,这种方法不仅能确保线程安全,也能保证单例的唯一性,同时也延迟了单例的实例化。
 
静态内部类又是如何实现线程安全的呢?
我们再回头 看下getInstance() 方法,调用的是SingleTonHoler.INSTANCE,取的是SingleTonHoler里的INSTANCE对象,跟上面那个DCL方法不同的是,getInstance()方法并没有多次去new对象,故不管多少个线程去调用getInstance()方法,取的都是同一个INSTANCE对象,而不用去重新创建 。当getInstance()方法被调用时,SingleTonHoler才在SingleTon的运行时常量池里,把符号引用替换为直接引用,这时静态对象INSTANCE也真正被创建,然后再被getInstance()方法返回出去,这点同饿汉模式。
 
那么INSTANCE在创建过程中又是如何保证线程安全的呢?
    5. 枚举单例模式
public enum Singleton {
    INSTANCE;
}

默认枚举实例的创建是线程安全的,并且在任何情况下都是单例。使用枚举除了线程安全和防止反射强行调用构造器之外,还提供了自动序列化机制,防止反序列化的时候创建新的对象。

public enum Singleton {
INSTANCE
//doSomething 该实例支持的行为
//可以省略此方法,通过Singleton.INSTANCE进行操作
public static Singleton get Instance() {
    return Singleton.INSTANCE;
}}

枚举单例模式在《Effective Java》中推荐的单例模式之一。但枚举实例在日常开发是很少使用的,就是很简单以导致可读性较差。

在以上所有的单例模式中,推荐静态内部类单例模式。主要是非常直观,即保证线程安全又保证唯一性。
众所周知,单例模式是创建型模式,都会新建一个实例。那么一个重要的问题就是反序列化。当实例被写入到文件到反序列化成实例时,我们需要重写readResolve方法,以让实例唯一。
private Object readResolve() throws ObjectStreamException{
    return singleton;
}

 

 
 
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值