美文网首页
单例模式

单例模式

作者: xdlkc | 来源:发表于2017-08-01 22:55 被阅读5次

    这个模式算是设计模式中比较简单的了,所以学的时间比较短,简单记录一下

    场景

    (本例子来自于设计模式之禅)
    中国历史悠久,从秦始皇开始了皇帝主宰整个国家,当然,同一个时代仅存在一个皇帝(后面会说一个特殊情况),大臣们都要听从皇帝发号施令,每天上朝向皇帝汇报任务,类比面向对象程序设计,相当于说是在当前运行环境下,仅存在某个类的一个实例,这个类就可以比作皇帝的位子,这个实例就是谁是皇帝,其他有调用这个类的方法或属性就相当于臣子向皇帝汇报,如何实现呢,关键之处就是只存在一个实例,实例的构造时机是在类初始化时发生的,那么就可以不让其他臣子类有构造皇帝类实例的权力即可,也就是构造方法私有化,那么如果私有化那怎样才能产生实例呢?我们其实可以构造一个当前类的静态对象,类型也是当前类,在其他臣子类想要汇报工作时返回这个对象即可,也就是下面这种情况:

    class Emperor{
        private static Emperor emperor = new Emperor();
        private Emperor(){
        
        }
        public static Emperor getEmperor() {
            return emperor;
        }
    }
    

    臣子可以这样调用它:

    class Vassal{
        public void report(String msg){
            System.out.println(Emperor.getEmperor()+"皇帝"+msg);
        }
    }
    

    通过getEmperor()方法来得到唯一的皇帝实例即可,当然这种方式最好理解,只通过简单的实现来解决这个例子,接下来正式介绍单例模式

    定义

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

    实现

    单例模式的实现有几种,上述的是最简单的,也叫做"饿汉式单例",因为实例在调用前就已经存在了,下面介绍另外一种实现方式:

    懒汉式(在调用时判断是否存在实例,不存在就创建一个):

    // 在调用时根据对象状态来决定是否构造对象,非线程安全
    class Sigleton1{
        private static Sigleton1 sigleton = null;
        private Sigleton1(){
    
        }
        public static Sigleton1 getInstance(){
            if (sigleton == null){
                sigleton = new Sigleton1();
            }
            return sigleton;
        }
    }
    

    这种是一般的思路,调用时判断对象是不是空,是的话new一个,不是的话直接返回即可,单线程下是没有问题的,多线程同步就会出现异常,比如还没有初始化时,A线程判断对象为空准备new,同时B线程也调用了get方法,也判断对象为空准备new,这时就会出现new了两次存在两个实例的情况,显然不符合我们期望的目标,那么我们就可以利用java的synchronized关键字来锁定对象或方法:

    // 线程安全,资源消耗较大
    class Sigleton2{
        private static Sigleton2 sigleton = null;
        private Sigleton2(){
    
        }
        public static synchronized Sigleton2 getInstance(){
            if (sigleton == null){
                sigleton = new Sigleton2();
            }
            return sigleton;
        }
    }
    // 线程安全,相对前者资源消耗较小
    class Sigleton3 {
        private static Sigleton3 sigleton = null;
        private Sigleton3(){
    
        }
        public static Sigleton3 getInstance(){
            if (sigleton == null){
                synchronized (sigleton){
                    if (sigleton == null){
                        sigleton = new Sigleton3();
                    }
    
                }
            }
            return sigleton;
        }
    }
    
    

    这样实现以后确实不会存在多线程同步问题,但是两者相比,下面的get方法显然锁定所消耗的资源更小,一个是方法级别,一个是对象级别,所以下面的更推荐使用,当然了也许会有疑问,有没有不同步也可以解决这个问题的呢,其实是有的,可以采用内部类调用的方式实现:

    // 线程安全,且资源消耗较小
    class Sigleton4 {
        private static class BetterSigleton{
            private static final Sigleton4 sigleton = new Sigleton4();
        }
        private Sigleton4(){
    
        }
        public Sigleton4 getInstance(){
            return BetterSigleton.sigleton;
        }
    }
    

    这种方法下,内部类已经存储了类的静态实例,get方法只需要返回内部类的静态对象即可,而内部类的初始化是在get方法时才会进行,所以也属于"懒汉式"

    两种方式比较

    • 饿汉式: 在获取实例之前已经初始化了,资源占用刚开始高一些,因为要一直维护这个实例,且线程安全
    • 懒汉式: 在获取实例时才去初始化对象,在获取实例时消耗一些资源,因为只在这时才会初始化,线程安全方面分情况,上面说的第1种非线程安全,2,3,4都是线程安全的

    感悟

    单例模式用的比较明显的地方就是spring的bean配置与管理了,对于一个类配置好了一个bean,在其他类用到的时候就把这个类的实例拿给它用就可以了,然后关于懒汉式的几种方式的应用场景,和相互的更深的比较还有待思考,有时间再学习

    相关文章

      网友评论

          本文标题:单例模式

          本文链接:https://www.haomeiwen.com/subject/zjollxtx.html