深入理解单例模式

基础 专栏收录该内容
22 篇文章 0 订阅

目录

【1】方法一:饿汉单例

【2】方法二:懒汉单例

【3】方法三:懒汉单例加强(同步方法)

【4】方法四:懒汉单例加强(DCL)

【5】方法五:DCL加强

【6】方法六:懒汉单例加强(静态内部类)

【6】方法七:枚举单例(最完美写法)

总结


 

单例模式有八种写法,不是说设计模式是代表了最佳的实践吗,这一下冒出八种写法,何谈最佳?

每一种单例的写法基本上都可以破坏其单例的属性,这就带来了安全隐患,所以每一种写法都是在之前的基础上进行加强,但是比消此涨,这会增加空间复杂度或者时间复杂度,没有最优的用法,只有最合适的用法。

这八种里面有些方法是重复的,只是写法稍变一下,重复的就不讲解了,每种方法通过多线程并发进行测试,通过构造方法执行的次数查看创建对象的数量

【1】方法一:饿汉单例

饿汉单例,顾名思义,饿汉就是比饿,比较饥渴,比较冲动,一上来就进入主题,创建对象。

  • 在类加载时就创建了单例对象
  • 只创建一个实例,绝对线程安全,在线程还没出现以前就是实例化了,不可能存在访问安全问题,JVM保证线程安全
  • 优点:没有加任何锁,执行效率高,线程安全
  • 缺点:不管你是否用到,类装载的时候就完成实例化,浪费内存空间(空间换时间)
public class Hungry {
    // 私有构造器
    private Hungry(){
        System.out.println(Thread.currentThread().getName());
    }
    // 指向自己实例的私有静态引用
    private static final Hungry hungry = new Hungry();
    // 以自己实例为返回值的静态的公有方法
    public static Hungry getInstance(){
        return hungry;
    }
}

// 多线程并发测试
@Test
public void TestMain1(){
    for (int i = 0;i < 10;i++){
        new Thread(() -> {
            Hungry.getInstance();
        }).start();
    }
}

image-20210205155802668

【2】方法二:懒汉单例

懒汉模式,就是比较懒,做事比较拖拉,在调用实例方法的时候才去实例化对象,一开始我就不给你 new 对象,你来找我,我再给你创建一个对象

  • 在调用实例方法的时候才去实例化对象
  • getInstance方法中线程不安全,会创建了多个实例
  • 优点:一直没人用的话,就不会创建实例,节约内存空间
  • 缺点:浪费判断时间,降低效率(时间换空间),线程不安全
public class LazyMan {
    // 私有构造器
    private LazyMan(){
        System.out.println(Thread.currentThread().getName());
    }
    // 指向自己实例的私有静态引用
    private static LazyMan lazyMan = null;
    // 以自己实例为返回值的静态的公有方法
    public static LazyMan getInstance(){
        if(lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

// 多线程并发测试
@Test
public void TestMain2(){
    for (int i = 0;i < 10;i++){
        new Thread(() -> {
            LazyMan.getInstance();
        }).start();
    }
}

image-20210205165553057

【3】方法三:懒汉单例加强(同步方法)

方法二存在线程不安全的隐患,我们可以通过加锁来进行加强,方法声明上加上 synchronized,同步方法

  • 和方法二一样,在调用实例方法的时候才去实例化对象
  • 在方法声明上加锁,保证线程安全
  • 优点:一直没人用的话,就不会创建实例,节约内存空间,且线程安全
  • 缺点:每次创建实例都要判断锁,浪费判断时间,降低效率(时间换空间)
public class LazyManSyn {
    // 私有构造器
    private LazyManSyn(){}
    // 私有静态引用创建对象
    private static LazyManSyn lazyManSyn = null;
    // 同步方法创建实例对象
    public static synchronized LazyManSyn getInstance(){
        if (lazyManSyn == null){
            lazyManSyn = new LazyManSyn();
        }
        return lazyManSyn;
    }
}

// 多线程并发测试
@Test
public void TestMain3(){
    for (int i = 0; i < 10; i++) {
        new Thread(()->{
            System.out.println(LazyManSyn.getInstance().hashCode());
        }).start();
    }
}

 

image-20210206103944913

【4】方法四:懒汉单例加强(DCL)

方法三虽然线程安全,但每次创建实例都需要判断锁,效率低,我们可以通过双重锁来进行加强,让已经有实例对象的时候不进行锁判断,这种方式称之为DCL懒汉式

  • 和方法二一样,在调用实例方法的时候才去实例化对象
  • 通过双重锁来防止多实例(双重判断和锁)
  • 第一个 if 判断:提高执行效率,如果对象不为空,就直接不执行下面的程序
  • 第二个 if 判断:在第一个 if 判断和 synchronized 锁之间,可以进来多个线程,如果没有第二个 if 判断,一个线程拿到锁 new 对象后释放锁,第二个线程又能够拿到锁 new 对象,通过第二个 if 则可以避免创建多个对象。
  • synchronized 锁:通过同步代码块
  • 优点:减少了锁的判断,相对于方法三提升了效率,使用双重锁,暂且认为线程安全(后面再说)
  • 缺点:其实这个方法还是存在线程不安全的隐患,在lazyManDCL = new LazyManDCL();创建对象的时候,不是一个原子性操作,会出现指令重排的可能,因此也可能创建多个实例
public class LazyManDCL {
    // 私有构造器
    private LazyManDCL(){}
    // 指向自己实例的私有静态引用
    private static LazyManDCL lazyManDCL = null;
    // 双重检查锁模式
    public static LazyManDCL getInstance(){
        if(lazyManDCL == null){
            synchronized (LazyManDCL.class){
                if(lazyManDCL == null){
                    lazyManDCL = new LazyManDCL();
                }
            }
        }
        return lazyManDCL;
    }
}

// 多线程并发测试
@Test
public void TestMain3(){
    for (int i = 0;i < 10;i++){
        new Thread(() -> {
            System.out.println(LazyManDCL.getInstance().hashCode());
        }).start();
    }
}

image-20210206103944913

【5】方法五:DCL加强

在DCL单例模式中,虽然能够通过双重锁保证一定的线程安全性,但是在 new 对象的时候,非原子性操作造成指令重排,执行 new LazyManDCL(); 的过程如下:

  1. 分配内存空间
  2. 执行构造方法
  3. 把这个对象指向这个空间

执行代码时,为了提高性能,编译器和处理器往往会对指令进行重排序,上面的执行顺序可能是 1—>2—>3,也可能是 1—>3—>2,当执行顺序为 1—>3—>2 时,就会出现如下问题:

  • A线程执行 1—>3 ,分配了内存空间,把这个对象指向这个空间
  • 此时B线程进来,由于A线程指向了这个空间,造成第一个 if 判断为 false,从而直接 return 对象,由于没有初始化对象,就会报错

因此我们要防止指令重排的现象发生,即:使用 volatile 关键字,代码如下,就是在方法四的基础上加了一个 volatile 关键字

  • 优点:线程安全
  • 缺点:多重判断,浪费时间,降低效率
public class LazyManDCL {
    // 私有构造器
    private LazyManDCL(){}
    // 指向自己实例的私有静态引用,使用volatile防止指令重排
    private static volatile LazyManDCL lazyManDCL = null;
    // 双重检查锁模式
    public static LazyManDCL getInstance(){
        if(lazyManDCL == null){
            synchronized (LazyManDCL.class){
                if(lazyManDCL == null){
                    lazyManDCL = new LazyManDCL();
                }
            }
        }
        return lazyManDCL;
    }
}

// 多线程并发测试
@Test
public void TestMain4(){
    for (int i = 0;i < 10;i++){
        new Thread(() -> {
            System.out.println(LazyManDCL.getInstance().hashCode());
        }).start();
    }
}

image-20210206115800861

【6】方法六:懒汉单例加强(静态内部类)

通过静态内部类来创建实例,静态内部类单例模式的核心原理为对于一个类,JVM在仅用一个类加载器加载它时,静态变量的赋值在全局只会执行一次!,

  • 优点1:外部类加载时,不会立即加载内部类,因此不占内存
  • 优点2:不像DCL那样需要进行多重判断,提升了效率
  • 优点3:第一次调用getInstance()方法时,虚拟机才加载SingleOne类,既能保证线程安全,又能保证实例的唯一性,同时也延迟了单例的实例化
public class SingleOne {
    // 私有构造方法
    private SingleOne(){}
    // 通过静态内部类创建实例
    private static class InnerClass{
        private static final SingleOne SINGLE_ONE = new SingleOne();
    }
    // 通过内部类返回对象实例
    public static SingleOne getInstance(){
        return InnerClass.SINGLE_ONE;
    }
}

// 多线程并发测试
@Test
public void TestMain5(){
    for (int i = 0; i < 10; i++) {
        new Thread(()->{
            System.out.println(SingleOne.getInstance().hashCode());
        }).start();
    }
}

image-20210206185449387

【6】方法七:枚举单例(最完美写法)

上面的方法都是在忽略反射的情况下,我们都知道,反射可以破坏类,能够无视私有构造器,因此,上面的单例都可以使用反射进行破坏,为了解决反射破坏,我们可以使用枚举单例。

  • 枚举的特性本身就是单例,在任何情况下都是一个单例
  • 直接通过EnumSingle.INVALID进行调用
  • 让JVM来帮我们保证线程安全和单一实例问题
public enum EnumSingle {
    INVALID;
    public void doSomething(){}
}

// 多线程并发测试
@Test
public void TestMain6(){
    for (int i = 0; i < 10; i++) {
        new Thread(()->{
            System.out.println(EnumSingle.INVALID.hashCode());
        }).start();
    }
}

image-20210206204120457

总结

单例模式写法有很多种,稍微改动一下可能又是一种,不过最完美的还是方法七的枚举单例,但是用的最多的还是第一种,因为简单,易于理解,更适合开发者。其实我们没有必要拘泥于完美,最合适的才是最好的,用什么方式解决实际问题更合适就用什么方式,不要追求那些不必要的完美。就像两个人在一起,可能他(她)足够完美,你很喜欢,然而却因为种种原因不是那么合适,喜欢是乍见之欢,久处仍怦然,合适是你来我往,听得懂和聊得来,你是用心动的方法还是用自己能够信手拈来的方法呢?当然,即喜欢又合适是最好的,无论多难,你也总会遇到即喜欢有合适的,毕竟地球是圆的,只是时间早晚的问题!

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值