什么是单例模式

因程序需要，有时我们只需要某个类同时保留一个对象，不希望有更多对象。

作用：

  • 保证1个类只有1个对象，降低对象之间的耦合度。

优点：

  • 提供了对唯一实例的受控访问
  • 由于在系统中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，采用单例模式可以提高系统的性能。

缺点：

  • 单例类的职责过重，里面的代码可能会过于复杂，在一定程度上违背了“单一职责原则”；
  • 如果实例化的对象长时间不被利用，会被系统认为是垃圾而被回收，导致丢失对象状态。

实现方式 

根据需求分为两大类：

A.初始化单例类时即创建单例

  1. 饿汉式
  2. 枚举类型

B.按需、延迟创建单例

  1.  懒汉式
  2.  静态内部类

1.1饿汉式

原理：依赖JVM类加载机制，保证单例只会被创建1次，线程安全。

  • JVM在类的初始化阶段(Class被加载后，被线程使用前)，会执行类的初始化。
  • 在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。
class Singleton {
    // 1. 加载该类时，单例就会自动被创建
    private static  Singleton ourInstance  = new  Singleton();

    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
    }

    // 3. 通过调用静态方法获得创建的单例
    public static  Singleton newInstance() {
        return ourInstance;
    }
}

初始化单例类时随即创建单例；单例对象初始化速度快，且占用内存小。

1.2枚举类型 

满足单例模式所需要的 创建单例、线程安全、实现简洁的需求

 

Android 单例模式多次调用线程安全吗 android单例模式优缺点_单例模式

实现：

public enum Singleton{

    //定义1个枚举的元素，即为单例类的1个实例
    INSTANCE;

    // 隐藏了1个空的、私有的 构造方法
    // private Singleton () {}

}

// 获取单例的方式：
Singleton singleton = Singleton.INSTANCE;

这是最简洁、易用的单例实现方式。

2.1 懒汉式

与饿汉式最大的区别：单例创建的时机

  • 饿汉式：单例创建时机不可控，类加载时自动创建单例
  • 懒汉式：创建时间可控，有需要时，手动创建。
class Singleton {
    // 1. 类加载时，先不自动创建单例
    //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；

    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
	
    }

    // 3. 需要时才手动调用 newInstance（） 创建 单例   
    public static  Singleton newInstance() {
        // 先判断单例是否为空，以避免重复创建
        if( ourInstance == null){
            ourInstance = new Singleton();
        }
        return ourInstance;
    }
}

缺点：线程不安全。原因如下：

 

Android 单例模式多次调用线程安全吗 android单例模式优缺点_内部类_02

2.2懒汉式改进(同步锁)

使用同步锁synchronized锁住创建单例的方法，防止多个线程同时调用，从而避免造成单例被多次创建。

  1. getInstance()方法块只能运行在1个线程中
  2. 若该段代码已在1个线程中运行，另外1个线程试图运行该块代码，则会被阻塞而一直等待
  3. 在这个线程安全的方法里我们实现了单例的创建，保证了多线程模式下单例对象的唯一性
class Singleton {
    // 1. 类加载时，先不自动创建单例
    //  即，将单例的引用先赋值为 Null
    private static  Singleton ourInstance  = null；

    // 2. 构造函数 设置为 私有权限
    // 原因：禁止他人创建实例 
    private Singleton() {
    }

// 3. 加入同步锁
public static synchronized Singleton getInstance(){
        // 先判断单例是否为空，以避免重复创建
        if ( ourInstance == null )
            ourInstance = new Singleton();
        return ourInstance;
    }
}

缺点：每次访问都要进行线程同步（调用synchronized锁），造成过多的同步开销。实际上，只需要在第1次调用该方法时才需要同步，一旦单例创建成功后，就没必要进行同步。

2.3懒汉式改进（双重检验锁）

在同步锁的基础上，添加1层 if 判断：若单例已创建，则不需要再执行加锁操作就可获取实例，从而提高性能。

class Singleton {
    private static  Singleton ourInstance  = null；

    private Singleton() {
    }

    public static  Singleton newInstance() {
     // 加入双重校验锁
     // 校验锁1：第1个if
    if( ourInstance == null){  // ①
        synchronized (Singleton.class){ // ②
            // 校验锁2：第2个 if
            if( ourInstance == null){
                ourInstance = new Singleton();
            }
        }
    }
    return ourInstance;
   }
}

说明：

校验锁1：第1个if

  • 作用：若单例已创建，则直接返回已创建的单例，无需再执行加锁操作，即可直接跳到执行 return ourInstance

校验锁2：第2个if

  • 作用：防止多次创建单例

原理：

  • 线程A调用newInstance()，当运行到②位置时，此时线程B也调用了newInstance()
  • 因线程A并没有执行instance = new Singleton();，此时instance仍为空，因此线程B能突破第1层 if 判断，运行到①位置等待synchronized中的A线程执行完毕
  • 当线程A释放同步锁时，单例已创建，即instance已非空
  • 此时线程B 从①开始执行到位置②。此时第2层 if 判断 = 为空（单例已创建），因此也不会创建多余的实例

缺点： 实现复杂，判断复杂，容易出错。

3.静态内部类

 原理：根据静态内部类的特性，同时解决了按需加载、线程安全的问题，同时实现简洁。

  • 在静态内部类中创建单例，在装载该内部类时才会去创建单例
  • 线程安全：类有JVM加载，而JVM只会加载一遍，保证只有1个单例
class Singleton {

    // 1. 创建静态内部类
    private static class Singleton2 {
       // 在静态内部类里创建单例
      private static  Singleton ourInstance  = new Singleton()；
    }

    // 私有构造函数
    private Singleton() {
    }

    // 延迟加载、按需创建
    public static  Singleton newInstance() {
        return Singleton2.ourInstance;
    }
}

调用过程说明：
 1. 外部调用类的newInstance() 
 2. 自动调用Singleton2.ourInstance
 2.1 此时单例类Singleton2得到初始化
 2.2 而该类在装载 & 被初始化时，会初始化它的静态域，从而创建单例；
 2.3 由于是静态域，因此只会JVM只会加载1遍，Java虚拟机保证了线程安全性
 3. 最终只创建1个单例

总结

 

Android 单例模式多次调用线程安全吗 android单例模式优缺点_初始化_03