栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java设计模式之单例模式【创建型】

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java设计模式之单例模式【创建型】

目录

​编辑

前言

开篇

什么是单例模式?

单例模式能解决什么问题?

项目中哪些地方使用了单例模式?

如何实现单例模式?

第一版

第二版【1.0】

第二版【2.0】

第二版【3.0】

第二版【最终版】

第三版


前言

大家好,我是爷爷的茶七里香,最近突然想做一个设计模式的系列,大家都知道设计模式有23种,而设计模式是由前人大量实践总结出来的,它是解决一些问题的最佳解决方案,我们今天就讲下单例模式中相对简单的单例模式吧。

开篇

什么是单例模式?

单例模式是在程序运行过程中一个类只有一个实例对象,不管调用了多少次,调用的都会是这个对象。

单例模式能解决什么问题?

首先我们使用单例模式可以提高我们的系统性能,试想一下,某个可以复用的对象创建过程十分复杂,每使用一次就要进行创建销毁的过程, 那么就浪费了不必要的资源了,一个简单的例子就是用来和数据库链接的对象,创建这个对象是比较消耗资源的,像这种对象每进行一次链接就创建一次新的对象,即浪费了空间又浪费了时间。

项目中哪些地方使用了单例模式?

在项目中我们的controller层调用service层、service层调用dao层,这两种情况使用的就是单例模式,它们为什么使用的是单例模式呢?因为它们的成员变量是不会改变的,它是静态的,如果说它们中的有一个成员变量的值是动态改变的,那么这个时候就不能用单例模式了,如果这个时候使用单例模式那么就会出现变量被污染的情况,比如两个线程去做操作,因为两个线程操作的是同一个对象,假设这个对象的成员变量有一个变量a,线程1去把a变量值修改为1,然后线程2去把a变量值修改为2,那么这个线程1读到的a变量就不是1而是2了,只有使用多利模式,让它们操作的对象不是同一个就不会出现这种情况了。想一下,controller层调用service会出现变量动态改变的情况吗?显然不会吧!因而才用单例模式!

如何实现单例模式?

要实现单例模式要看以下几点:

  • 是否懒加载
  • 是否线程安全
  • 是否能被反射破坏(这种情况基本上是人为的,不需要考虑)

第一版
public class OneObject {
    // 私有构造器
    private OneObject() {}
    private static OneObject oneObject = new OneObject();
    public static OneObject getOneObject() {
        return oneObject;
    }
}

测试:

public static void main(String[] args) {
        System.out.println("OneObject1 = " + OneObject.getOneObject());
        System.out.println("OneObject2 = " + OneObject.getOneObject());
        System.out.println("OneObject3 = " + OneObject.getOneObject());
    }

打印结果:

OneObject1 = xyz.keydoisdls.test.OneObject@312b1dae
OneObject2 = xyz.keydoisdls.test.OneObject@312b1dae
OneObject3 = xyz.keydoisdls.test.OneObject@312b1dae 

这种写法可以避免了性能的浪费也能做到线程安全,但是它并不是懒加载的,因为它是在项目启动就把对象创建好了,如果这个对象一直都用不到,那么就浪费内存了,这种写法用不用就看个人情况吧! 

注:懒加载的意思是当我需要使用这个对象的时候才去创建,并不会在项目启动的时候就把对象创建好了! 项目启动就把对象创建好了,可能会一辈子都用不到这个对象,那么就浪费资源了,所以使用懒加载可以减少资源的占用。

第二版【1.0】
public class OneObject {
    // 私有构造器
    private OneObject() {}
    // 懒加载
    private static OneObject oneObject = null;
    public static OneObject getOneObject() {
        if (oneObject == null){
            // 第一次进来是空的,创建一个实例
            oneObject = new OneObject();
        }
        // 不为空直接返回
        return oneObject;
    }
}

这种写法可以做到懒加载,但是如果是多线程的情况下会发生什么呢?可能会出现两条线程同时进入进行null值判断,这样就出现了一个类有两个实例了,这样它就不是单例了,所以我们需要考虑是否安全的情况,因此这种写法不采用,会出现线程不安全的情况。 

第二版【2.0】
public class OneObject {
    // 私有构造器
    private OneObject() {}
    private static OneObject oneObject = null;
    // 相比第一种多了synchronized关键字(自动锁)
    public static synchronized OneObject getOneObject() {
        if (oneObject == null){
            // 第一次进来是空的,创建一个实例
            oneObject = new OneObject();
        }
        // 不为空直接返回
        return oneObject;
    }
}

可以看到在函数上多了一个synchronized关键字,这种写法可以做到懒加载+线程安全,但是比较消耗性能,你想一下,我们什么时候需要加锁呢?只有在创建对象的时候加,对吧?但是现在我连获取一个对象都要线程去竞争,那么就很浪费性能了,所以这种写法也不可取! 

第二版【3.0】
public class OneObject {
    // 私有构造器
    private OneObject() {}
    // volatile关键字避免指令重排导致空指针
    private volatile static OneObject oneObject = null;
    public static OneObject getOneObject() {
        if (oneObject == null){
            // 对第一次进来创建对象加锁
            synchronized (OneObject.class){
                oneObject = new OneObject();
            }
        }
        // 不为空直接返回
        return oneObject;
    }
}

 该写法相较于上一个版本避免了性能的问题,只有在创建对象的时候上锁,获取对象不会进行上锁,但是这个写法还是会有问题,如果两条线程同时进行判空操作,两条线程不管是哪条先抢到锁执行了new OneObject()的操作,另外一条也肯定会执行该操作,所以也会出现线程不安全的情况。

第二版【最终版】
public class OneObject {
    // 私有构造器
    private OneObject() {}
    // volatile关键字避免指令重排导致空指针
    private volatile static OneObject oneObject = null;
    public static OneObject getOneObject() {
        if (oneObject == null){
            // 对第一次进来创建对象加锁
            synchronized (OneObject.class){
                // 再次判断
                if (oneObject == null){
                    oneObject = new OneObject();
                }
            }
        }
        // 不为空直接返回
        return oneObject;
    }
}

这种写法可以完美的解决了懒加载+线程安全,看代码可以看到我们进行了两次判断,这个也叫做双检锁,让我们假设两条线程同时通过了第一个判断,第一条线程恰好抢到锁了,执行代码块的内容,又进行了一次判断,这个时候肯定是空的,创建好了对象并赋值释放锁;轮到第二条线程进入代码块了,当它又进行一次判断时发现不为空了,它就不做后续的操作了,然后释放锁,返回对象;

第三版
public class OneObject {
    // 私有构造器
    private OneObject() {
    }

    // 静态内部类
    private static class One {
        private static final OneObject ONE_OBJECT = new OneObject();
    }

    public static  OneObject getOneObject(){
        return One.ONE_OBJECT;
    }
}

我们都知道静态内部类是在调用的时候才会去初始化,所以我们可以利用这个特性实现单例的创建,既能做到线程安全也能做到懒加载,更是简化了代码;

以上能做到单例模式,但是都会被反射破坏,反射可以忽略任何,它可以直接调用构造器,即使你的构造器是私有的,但是这点可以不需要考虑,反射基本是人为的,只要你不去恶意的搞事情,基本忽略,如果硬要做到的话可以自己去了解下枚举类,使用枚举类实现单例的话可以做到不能被反射破坏,也能做到线程安全,但是它不是懒加载的,感兴趣的话自己私下了解下吧!

今天就到这里啦~对你有帮助的话不妨留个赞呗!

 磊原创不易,还希望各位大佬支持一下!

点赞,你的认可是我创作的动力 !

收藏,你的青睐是我努力的方向!

✏️评论,你的意见是我进步的财富! 

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/961476.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号