欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  移动技术

荐 「 Android 10 设计模式 」系列 -- “ 单例 “

程序员文章站 2022-06-28 18:31:48
作者:DeepCoder一、概述1.1 什么是单例?这种模式涉及到一个 单一的类 ,该类负责 创建自己的对象 ,同时确保 只有单个对象被创建 。这个类 提供了一种访问其唯一的对象的方式 ,可以直接访问, 不需要实例化该类的对象 。我们需要注意:单例类 :只能有一个实例(有且唯一)。单例类 :必须自己创建自己的唯一实例(自己创建自己)。单例类 :必须给所有其他对象提供这一实例(提供给别人调用自己的方法)。1.2 举个例子我们看个简单的 “单例设计” 的 Demo,先创建一个 Single....

作者:DeepCoder

一、概述

1.1 什么是单例?

这种模式涉及到一个 单一的类 ,该类负责 创建自己的对象 ,同时确保 只有单个对象被创建 。这个类 提供了一种访问其唯一的对象的方式 ,可以直接访问, 不需要实例化该类的对象 。

我们需要注意:

单例类 :只能有一个实例(有且唯一)。

单例类 :必须自己创建自己的唯一实例(自己创建自己)。

单例类 :必须给所有其他对象提供这一实例(提供给别人调用自己的方法)。

1.2 举个例子

我们看个简单的 “单例设计” 的 Demo,先创建一个 Singleton(单例) 类: SingleObject.java

public class SingleObject {
 
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();    --> 1、有且仅有一个实力;2、自己创建自己的实例
 
   // 让构造函数为 private,这样该类就无法被实例化
   private SingleObject(){}
 
   // 获取唯一可用的对象
   public static SingleObject getInstance(){    --> 3、为其他对象提供自己的实例
      return instance;
   }
 
   public void showMessage(){
      System.out.println("Hello World!");
   }
}

然后我们再创建一个类 SingletonPatternDemo.java 去获取 SingleObject 的实例:

public class SingletonPatternDemo {
   public static void main(String[] args) {
 
      // 不合法的构造函数,编译时错误:构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();
 
      // 获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
 
      // 显示消息
      object.showMessage();
   }
}

我们看下执行结果:

Hello World!

二、实现方式

2.1 基本版:饿汉式

代码范例

public class Singleton {  

        private static Singleton instance = new Singleton();    // 类加载时就初始化
        private Singleton (){}  
    
        public static Singleton getInstance() {  
            return instance;  
        }  
    }

方法说明

这种方式比较常见,典型的 “饿汉式” 写法。

荐
                                                        「 Android 10 设计模式 」系列 -- “ 单例 “

2.2 改进版:懒汉式 - 线程不安全

代码范例

public class Singleton {  

        private static Singleton instance;    // 类加载时不作初始化
        private Singleton (){}  
  
        public static Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
    }

方法说明

这种方式是大多数面试者的写法,也是教科书上的标配,但这段代码却存在一个致命的问题:当多个线程并行调用 getInstance() 的时候,就会创建多个实例。

荐
                                                        「 Android 10 设计模式 」系列 -- “ 单例 “

2.3 改进版:懒汉式 - 线程安全

代码范例

public class Singleton {  

        private static Singleton instance;  
        private Singleton (){}  
    
        public static synchronized Singleton getInstance() {    // 加锁
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
    }

方法说明

既然要线程安全,那就如上所述进行 “加锁” 处理!

荐
                                                        「 Android 10 设计模式 」系列 -- “ 单例 “

2.4 改进版:双重校验锁

代码范例

public class Singleton {  

        private static Singleton instance;  
        private Singleton (){}  
    
        public static Singleton getSingleton() {  
            if (instance == null) {  
                synchronized (Singleton.class) {  
                    if (instance == null) {  
                        instance = new Singleton();  
                    }  
                }  
            }  
            return instance;  
        }  
    }

方法说明

为什么需要进行 2 次判断是否为空呢?

第一次判断是为了避免不必要的同步,第二次判断是确保在此之前没有其他进程进入到 synchronized 块创建了新实例。

这段代码看起来很完美,很可惜,它还是有隐患!

主要在于 instance = new Singleton() 这句,这并非是一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情:

✵ 1、给 instance 分配内存

✵ 2、调用 Singleton 的构造函数来初始化成员变量

✵ 3、将 instance 对象指向分配的内存空间(执行完这步 instance 就为非 null 了)

但是在 JVM 的即时编译器中存在 指令重排序 的优化。也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,最后顺理成章地报错。

2.5 改进版:双检锁(volatile)

代码范例

public class Singleton {  

        private volatile static Singleton instance;  
        private Singleton (){}  
    
        public static Singleton getSingleton() {  
            if (instance == null) {  
                synchronized (Singleton.class) {  
                    if (instance == null) {  
                        instance = new Singleton();  
                    }  
                }  
            }  
            return instance;  
        }  
    }

方法说明

有些人认为使用 volatile 的原因是可见性,也就是可以保证线程在本地不会存有 instance 的副本,每次都是去主内存中读取。但其实是不对的。

使用 volatile 的主要原因是其另一个特性:禁止指令重排序优化。

也就是说,在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。比如上面的例子,取操作必须在执行完 1-2-3 之后或者 1-3-2 之后,不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话,就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作(这里的“后面”是时间上的先后顺序)。

但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM (Java 内存模型)是存在缺陷的,即使将变量声明成 volatile 也不能完全避免重排序,主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复,所以在这之后才可以放心使用 volatile。

那么,有没有一种既有懒加载,又保证了线程安全,还简单的方法呢?

当然有, 静态内部类就是这么一种我们想要的方法 。我们完全可以把 Singleton 实例放在一个静态内部类中,这样就避免了静态实例在 Singleton 类加载的时候就创建对象,并且由于静态内部类只会被加载一次,所以这种写法也是线程安全的。

2.6 终极版:静态内部类

代码范例

public class Singleton {  

        private static class SingletonHolder {  
            private static final Singleton INSTANCE = new Singleton();  
        }  
    
        private Singleton (){}  
    
        public static final Singleton getInstance() {  
            return SingletonHolder.INSTANCE;  
        }  
}

方法说明

这是比较推荐的解法,这种写法用 JVM 本身的机制保证了线程安全的问题,同时读取实例的时候也不会进行同步,没什么性能缺陷,还不依赖 JDK 版本。

2.7 传说版:枚举

代码范例

public enum Singleton {  
        INSTANCE;  
    }

方法说明

这是从 Java 1.5 发行版本后就可以实用的单例方法,我们可以通过 Singleton.INSTANCE 来访问实例,这比调用 getInstance() 方法简单多了。

创建枚举默认就是线程安全的,所以不需要担心 double checked locking(双重校验锁) ,而且还能防止反序列化导致重新创建新的对象。

三、总结

以上就是「 Android 10 设计模式 」系列 – " 单例 "的内容了

在这我也分享一份大佬自己收录整理的Android学习PDF+架构视频+面试文档+源码笔记,还有高级架构技术进阶脑图、Android开发面试专题资料,高级进阶架构资料这些都是我闲暇还会反复翻阅的精品资料

总之也是在这里帮助大家学习提升进阶,也节省大家在网上搜索资料的时间来学习,也可以分享给身边好友一起学习

如果你有需要的话,可以点赞+评论 关注我,然后私信我获取~

点击【Android学习PDF+架构视频+面试文档+源码笔记】加入我们的圈子领取资料和我们一起吧学习交流吧!

本文地址:https://blog.csdn.net/ajsliu1233/article/details/107364366