目录
1. 什么是单例模式
单例模式是 java 中最常见的设计模式之一. 这种模式涉及到了一个单一的类, 该类负责创建自己的对象,同时确保只有单个对象被创建.
换句话说, 就是:某些类的对象, 在整个应用的生命过程, 需要且仅需要一份
2. 单例模式的特点
单利模式的特点如下:
- 单例类只能有一个实例.
- 单例类必须自己创建自己的唯一实例.
- 单例类必须给其他所有对象提供这一实例
3. 单例模式的两种思想实现
单例模式中, 最常见的就是: 饿汉单例模式 和 懒汉单例模式, 接下来, 将对这两种模式进行进一步的详述.
3.1. 饿汉模式单例(天生线程安全)
饿汉模式: 一开始类加载的时候就实例化好对象, 以后需要的时候只管使用即可.
/**
* 饿汉单例模式:
* 1. 保存仅有的一个引用至一个静态变量中
* 2. 一开始就对这个变量进行初始化(可以使用静态代码块 / 直接初始化)
* 3. 提供一个方法可以返回这个对象
* 4. 避免无意中犯错, 应该将这个类的构造方法标记成 private 的
*/
public class SingletonStarve {
// 使用 final 修饰, 保证了原子性
private static final SingletonStarve instance;
// 变量只有在 SingletonStarve 被加载时才会执行, 而 SingletonStarve 这个类只会被加载一次
static {
instance = new SingletonStarve();
}
// 需要提供一个方法返回这个对象, 凡是要使用 instance 这个对象, 只能调用这个方法
public static SingletonStarve getInstance() {
return instance;
}
// 尽可能避免有人无意中构造出这个对象, 将这个类的构造方法标记成 private 的
private SingletonStarve() {
}
}
饿汉模式的缺点:
饿汉模式实例化好的对象是会占用一部分空间的, 如果一直不调用, 就可能会造成空间的浪费.
3.2. 懒汉模式单利(天生是线程不安全的)
懒汉模式: 延迟初始化, 即: 按需加载, 使用的时候再初始化对象.
懒汉模式一般情况下是线程不安全的.
在这里需要说明两种典型的线程不安全的情况:
- read and write(读写): a = b; v++
- check and modify(判断修改): if(…) {…}
(在多线程的环境下, 真正执行时, 条件可能已经发生改变)
3.2.1. 线程不安全的懒汉模式
**
* 懒汉单例模式:
* 1. 保存仅有的一个对象至静态属性中
* 2. 提供一个方法, 当需要使用时再进行初始化并返回
* 3. 为了避免无意中构造对象, 将这个类的构造方法标记成 private 的
*/
public class SingletonLazy {
// 保存对象至静态属性中
private static SingletonLazy instance = null;
// 提供初始化并返回这个对象的方法
public static SingletonLazy getInstance() {
// getInstance 这个方法被调用了, 说明有人需要该类的对象了
if(instance == null) {
instance = new SingletonLazy();
}
return instance;
}
// 将这个对象的构造方法标记成 private 的
private SingletonLazy() {
}
}
为什么这种情况下线程是不安全的?
凡是需要使用 instance 这个对象时, 都只能调用 getInstance() 这个方法.
线程 A 在调用该方法时判断 Instance == null 的, 那么他认为这时 instance 对象还没有被实例化. 这时, 线程 B 抢占了 CPU, 同时在调用该方法时判断 Instance == null, 并实例化 instance 对象. 当 CPU 再次轮到 线程 A 时, 由于内存可见性问题, 线程 A 仍旧以为 instance 为 null, 进而再次实例化 instance 对象, 违背了单例模式的特点. 所以是线程不安全的.
3.2.2. 线程安全的懒汉模式
public class SingletonLazy {
private static volatile SingletonLazy instance = null;
public static SingletonLazy getInstance() {
if(instance == null) {
synchronized (SingletonLazy.class) {
if(instance == null) {
instance = new SingletonLazy();
}
}
}
return instance;
}
private SingletonLazy() {
}
}
这种懒汉模式下, 使用了 synchronized + 二次判断 + volatile 修饰:
- 将引用保存至静态变量时, 可能会出现代码重排序的情况, 因此可能会出现问题, 所以需要使用 volatile 关键字进行修饰.
- 当对象还未被实例化时(instance == null), 才使用synchronized 对当前类进行加锁.
- 进行了二次判断(instance == null). 防止多次实例化对象.
懒汉模式的优点:
由于是按需加载, 所以减少了空间的浪费.