您现在的位置是:网站首页>>信息浏览 文章详情

深入理解5种单例模式以及对其的改造在多线程下的使用
2019-06-03 11:19 许多年以后 1502

我们常用的单例模式有:

饿汉模式、懒汉模式、双重锁懒汉模式、静态内部类模式、枚举模式,我们分析下这些模式的区别以及对其的改造。

1.饿汉模式:

  1. public class SingleTon{
  2. private static SingleTon INSTANCE = new SingleTon();
  3. private SingleTon(){}
  4. public static SingleTon getInstance(){ return INSTANCE; }}

由于INSTANCE是静态变量,在类初始化时就分配空间和正确的值了而且由于<clinit>方法会保证多线程的同步性,所以可以用在多线程环境下。

2.懒汉模式:

  1. public class SingleTon{
  2. private static SingleTon INSTANCE = null;
  3. private SingleTon(){}
  4. public static SingleTon getInstance() {
  5. if(INSTANCE == null){
  6. INSTANCE = new SingleTon();
  7. }
  8. return INSTANCE
  9. }
  10. }

懒汉模式在方法被调用后才创建对象,在多线程环境下,有可能多个线程同时到达 if(INSTANCE == null),使INSTANCE不是唯一性,所以在多线程环境下存在风险。但是我们可以对其加锁

  1. public class SingleTon{
  2. private static SingleTon INSTANCE = null;
  3. private SingleTon(){}
  4. public synchronized static SingleTon getInstance() {
  5. if(INSTANCE == null){
  6. INSTANCE = new SingleTon();
  7. }
  8. return INSTANCE
  9. }
  10. }

虽然这样可以达到同步,但是synchronized关键字只能在同一时间只有一个线程访问,这样性能就不好了
3.双重锁懒汉模式(Double Check Lock)

  1. public class SingleTon{
  2. private static SingleTon INSTANCE = null;
  3. private SingleTon(){}
  4. public static SingleTon getInstance(){if(INSTANCE == null){
  5. synchronized(SingleTon.class){
  6. if(INSTANCE == null){
  7. INSTANCE = new SingleTon();
  8. }
  9. }
  10. return INSTANCE;
  11. }
  12. }
  13. }

DCL模式的优点就是,只有在对象需要被使用时才创建,第一次判断 INSTANCE == null为了避免非必要加锁,当第一次加载时才对实例进行加锁再实例化。这样既可以节约内存空间,又可以保证线程安全。但是,由于jvm存在乱序执行功能,DCL也会出现线程不安全的情况。具体分析如下:

INSTANCE = new SingleTon();
这个步骤,其实在jvm里面的执行分为三步:

  • 1.在堆内存开辟内存空间。
  • 2.在堆内存中实例化SingleTon里面的各个参数。
  • 3.把对象指向堆内存空间。

由于jvm存在乱序执行功能,所以可能在2还没执行时就先执行了3,如果此时再被切换到线程B上,由于执行了3,INSTANCE 已经非空了,会被直接拿出来用,这样的话,就会出现异常。这个就是著名的DCL失效问题。

不过在JDK1.5之后,官方也发现了这个问题,故而具体化了volatile,即在JDK1.6及以后,只要定义为private volatile static SingleTon INSTANCE = null;就可解决DCL失效问题。volatile确保INSTANCE每次均在主内存中读取,这样虽然会牺牲一点效率,但也无伤大雅。

  1. public class SingleTon{
  2. private volatile static SingleTon INSTANCE = null;
  3. private SingleTon(){}
  4. public static SingleTon getInstance(){if(INSTANCE == null){
  5. synchronized(SingleTon.class){
  6. if(INSTANCE == null){
  7. INSTANCE = new SingleTon();
  8. }
  9. }
  10. return INSTANCE;
  11. }
  12. }
  13. }

4.静态内部类模式:

  1. public class SingleTon{
  2. private SingleTon(){}
  3. private static class SingleTonHoler{
  4. private static SingleTon INSTANCE = new SingleTon();
  5. }
  6. public static SingleTon getInstance(){
  7. return SingleTonHoler.INSTANCE;
  8. }
  9. }

静态内部类的优点是:外部类加载时并不需要立即加载内部类,内部类不被加载则不去初始化INSTANCE,故而不占内存。即当SingleTon第一次被加载时,并不需要去加载SingleTonHoler,只有当getInstance()方法第一次被调用时,才会去初始化INSTANCE,第一次调用getInstance()方法会导致虚拟机加载SingleTonHoler类,这种方法不仅能确保线程安全,也能保证单例的唯一性,同时也延迟了单例的实例化。

那么,静态内部类又是如何实现线程安全的呢?首先,我们先了解下类的加载时机。

类加载时机:JAVA虚拟机在有且仅有的5种场景下会对类进行初始化。

  • 1.遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时,对应的java代码场景为:new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。
  • 2.使用java.lang.reflect包的方法对类进行反射调用的时候,如果类没进行初始化,需要先调用其初始化方法进行初始化。
  • 3.当初始化一个类时,如果其父类还未进行初始化,会先触发其父类的初始化。
  • 4.当虚拟机启动时,用户需要指定一个要执行的主类(包含main()方法的类),虚拟机会先初始化这个类。
  • 5.当使用JDK 1.7等动态语言支持时,如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄,并且这个方法句柄所对应的类没有进行过初始化,则需要先触发其初始化。
  • 这5种情况被称为是类的主动引用,注意,这里《虚拟机规范》中使用的限定词是”有且仅有”,那么,除此之外的所有引用类都不会对类进行初始化,称为被动引用。静态内部类就属于被动引用的行列。

我们再回头看下getInstance()方法,调用的是SingleTonHoler.INSTANCE,取的是SingleTonHoler里的INSTANCE对象,跟上面那个DCL方法不同的是,getInstance()方法并没有多次去new对象,故不管多少个线程去调用getInstance()方法,取的都是同一个INSTANCE对象,而不用去重新创建。当getInstance()方法被调用时,SingleTonHoler才在SingleTon的运行时常量池里,把符号引用替换为直接引用,这时静态对象INSTANCE也真正被创建,然后再被getInstance()方法返回出去,这点同饿汉模式。那么INSTANCE在创建过程中又是如何保证线程安全的呢?在《深入理解JAVA虚拟机》中,有这么一句话:

虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的<clinit>()方法,其他线程都需要阻塞等待,直到活动线程执行<clinit>()方法完毕。如果在一个类的<clinit>()方法中有耗时很长的操作,就可能造成多个进程阻塞(需要注意的是,其他线程虽然会被阻塞,但如果执行<clinit>()方法后,其他线程唤醒之后不会再次进入<clinit>()方法。同一个加载器下,一个类型只会初始化一次。),在实际应用中,这种阻塞往往是很隐蔽的。

故而,可以看出INSTANCE在创建过程中是线程安全的,所以说静态内部类形式的单例可保证线程安全,也能保证单例的唯一性,同时也延迟了单例的实例化。

5.枚举单例:
//枚举类本身时final,不被继承

  1. public enum SingleTon{
  2. INSTANCE;
  3. public static void method(){
  4. //TODO
  5. }
  6. public static SingleTon getInstance(){
  7. return INSTANCE;
  8. }
  9. }

枚举在java中与普通类一样,都能拥有字段与方法,而且枚举实例创建是线程安全的,在任何情况下,它都是一个单例。

总结:一般我们都是用后面2种来创建单例模式的。

赞 (132)
文章出处:书生个人博客          转载注明下哦!o(≧v≦)o~~

标签: 单例模式多线程类加载

相似文章:


随便说两句
请先登录
遵守国家法律法规,请勿回复无意义内容,请不要回复嵌套过多的楼层!