码迷,mamicode.com
首页 > 编程语言 > 详细

Java设计模式之单例模式 - Singleton

时间:2019-05-13 16:35:34      阅读:177      评论:0      收藏:0      [点我收藏+]

标签:数据库连接池   问题:   创建   设计模式之单例模式   jvm   线程   alt   对比   turn   

用来创建独一无二的,是能有一个实例的对象的入场券。告诉你一个好消息,单例模式的类图可以说是所有模式的类图中最简单的,事实上,它的类图上只有一个类!但是,可不要兴奋过头,尽管从类设计的视角来说很简单,但是实现上还是会遇到相当多的波折。所以,系好安全带,出发了!

介绍

定义

单例模式(Singleton Pattern):确保一个类只有一个实例,并提供一个全局访问点。

常用情景

有些对象其实我们只需要一个,比如:windows的任务管理器,项目中的读取配置文件的对象,数据库连接池,spring中的bean默认也是单例,线程池(threadpool),缓存(cache),对话框,处理偏好设置和注册表(registry)的对象,日志对象,充当打印机,显卡等设备的驱动程序的对象。事实上,这类对象只能有一个实例,如果制造出多个实例,就会导致许多问题产生,例如:程序的行为异常,资源使用过量,或者是不一致的结果。

要点

优点

  1. 单例模式存在一个全局访问点,所以优化共享资源;
  2. 只生成一个实例,减少了开销,对于一些需要频繁创建和销毁的对象,单例模式可以提高系统性能。

缺点

  1. 由于单例模式中没有抽象层,因此扩展困难;
  2. 职责过重,在一定程度上违背了“但一职责原则”。

类图

在java中实现单例模式需要注意以下三点:

  1. 私有的构造器;
  2. 一个静态方法;
  3. 一个静态变量。

单例模式的实现

饿汉式

代码实现

/** 通过饿汉式创建单例模式
 * 当前类只能创建一个对象
 * 天然线程安全(类只要被加载,就会被加载到全局变量中。所以饿汉式就是及时加载,不能实现懒加载)
 */
public class SingleHungry {
    
    //提供一个静态的全局变量作为访问该实例的入口
    private static SingleHungry instance = new SingleHungry(); 
    
    /**
     * 构造器私有,不让外部通过new创建实例
     */
    private SingleHungry() {}
    
    /**
     * 对外提供静态的方法,用来获取该类的实例
     */
    public static SingleHungry getInstance() {
        return instance;
    }
}

要点

优点:线程安全;
缺点:不能懒加载。

懒汉式

代码实现

/**
 * 懒汉式,完成单例模式:
 *          静态的全局变量,初始化放在了静态方法中,延迟产生了实例
 * 延迟加载
 * 线程不安全
 */
public class Singlelazy {
    //提供一个静态的全局变量作为访问该实例的入口,但不立即加载
    private static Singlelazy instance = null;
    
    /**
     * 构造器私有
     */
    private Singlelazy() {
        System.out.println("构造器被调用了");
    }
    
    /**
     * 提供方法获取该类的实例
     * @return
     */
    public static Singlelazy getInstance() {
        //先查看是否存在对象,不存在则创建
        if(instance == null) {
            instance = new Singlelazy();
        }
        return instance;
    }
}

以上代码存在的问题如图:

技术图片

这段代码是线程不安全的,当有多个线程同时访问该代码时,会出现创建多个实例的情况。
为了方便理解,我以Head First设计模式中的图来介绍:

技术图片

以上模拟了多线程问题的运行步骤,只是对象的名称不一样而已,相信对你来说是没问题的。

解决思路1:

加锁。锁方法

技术图片

问题:可以解决问题,但锁住整个方法的粒度太大了,效率较低。不推荐使用

解决思路2:

加锁。锁代码块,先判断后锁

技术图片

问题:不能解决问题,以上方式锁的粒度变小了,但是并不能产生一个实例。原因:多个线程判断之后全局变量都是null,进入后都开始等锁。线程1出去,线程2进来继续实例化,所以得到的对象是多个。

解决思路3:

加锁。锁代码块,先锁后判断。

技术图片

以上方式解决了问题,当有多个线程同时访问getInstance()。保证了多个线程是以流式,次序性的进入当前方法来获取该类的实例。那么效率一样很低。而且多个线程同时等待。

上面的解决方法似乎都不怎么好,那么有没有一种更好的方法来解决懒汉式的多线程安全问题呢?请继续探索... ...

双重检测(双重校验锁)

代码实现


public class Singlelazy {
    /*
     * 双重检测(双重校验锁)
     * 延迟加载
     * 线程安全
     */
        private static volatile Singlelazy instance;
        
        /*
         * 构造器私有
         */
        private Singlelazy() {
            System.out.println("构造器被调用了");
        }
        
        public static Singlelazy getInstance() {
            if(instance == null) {
                synchronized (Singlelazy.class) {
                    if(instance == null) {
                        instance = new Singlelazy();
                    }
                }
            }
            return instance;
        }
}

要点

volatile关键字确保:当instance变量被初始化成Singleton实例时,多个线程正确地处理instance变量。

值得注意的是:很不幸地,在jdk1.5之前的版本,许多JVM对于volatile关键字的实现会导致dcl(double check locking)失效。如果你不能使用jdk1.4之后的版本,就请不要利用此技巧实现单例模式。

双重检测很好的解决了懒汉式多线程安全问题,可以和之前的几种解决思路对比一下,思考一下优点在哪里!

解决思路:

我们知道为了解决这个线程安全问题,必须加锁,并且必须先锁后判断,思路3已经解决了问题,为了进一步优化代码执行效率,我们再来改进一下代码:

技术图片

我们在锁的外面再加一层对全局变量的判断,这么做的效果是什么呢?当有多个线程来访问时,例如:

  1. 线程1,线程2同时进入该方法;
  2. 经过最外面的判断后,发现还没有创建实例,这时就会依次执行锁里的逻辑,并创建了实例;
  3. 假如这时线程3进入该方法,执行最外面的判断,发现已经创建了实例,这时候直接返回就可以了,并不需要等锁。

静态内部类(饿汉式的变种)

代码实现

/*
 * 静态内部类创建单例(利用类加载机制,保证线程安全问题)
 * 线程安全
 * 懒加载
 */
public class SingleInner {
    
    private SingleInner() {}
    
    private static class SingleInnerHolder{
        private static SingleInner instance = new SingleInner();
    }
    public static SingleInner getInsstance() {
        return SingleInnerHolder.instance;
    }
}

要点

和饿汉式一样采用的是classLoader机制,保证了线程安全问题,但不同的是,静态内部类同样满足懒加载(当调用getInsstance()方法时,实例才会被创建)。

枚举实现

代码实现

public enum SingleEnum {

    //定义示例化的单例对象
    INSTANCE;
    
    /*
     * 对象执行的功能
     */
    public void getInstance() {
        
    }
}

要点

枚举类的单例模式,不存在出现序列化,反射构建对象的漏洞(前面几种单例实现方式都存在此问题)。不能懒加载。默认情况枚举实例的创建都是线程安全,但是实例对象实现的方法,需要自己保证线程安全问题。

反射,序列化与单例的关系

反射

我们以饿汉式为例,如下图:

技术图片

通过反射获取的s3和通过饿汉式获取的s1,s2,并不是同一个实例,那么有什么办法可以解决反射对单例的影响呢!请看下面:

解决方法:

我们通过改变饿汉式构造方法的方式,来解决这个问题:

技术图片

调用时抛出异常:

技术图片

序列化

依旧以饿汉式为例,如下图:

技术图片

通过序列化,反序列化获取的s3和通过饿汉式获取的s1,s2,并不是同一个实例,那么有什么办法可以解决序列化,反序列化对单例的影响呢!请看下面:

技术图片

通过在饿汉式中加入此方法,就可以解决这个问题:

技术图片

创建的构建单例模式的方式比较

  • 饿汉式 效率较高 不能懒加载 线程安全 调用率高
  • 懒汉式 效率较低 懒加载 线程不安全
  • 双重检测(双重校验锁)懒汉式的一个变种 效率较高 懒加载 线程安全
  • 静态内部类 饿汉式的变种 效率较高 懒加载 线程安全
  • 枚举 效率较高 线程安全 不能懒加载

用法总结

  1. 懒汉式效率最低;
  2. 占用资源较少 不需要懒加载 枚举优先 饿汉式;
  3. 占用资源较多 需要懒加载 静态内部类优先 懒汉式(优先使用DCL)。

    结语

    设计模式源于生活

Java设计模式之单例模式 - Singleton

标签:数据库连接池   问题:   创建   设计模式之单例模式   jvm   线程   alt   对比   turn   

原文地址:https://www.cnblogs.com/J-Simon/p/10856630.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!