【设计模式】各个击破单例模式的8种写法
共 6941字,需浏览 14分钟
·
2020-12-11 04:40
单例模式
在一个系统开发过程中,我们在基于节省内存资源、保证数据内容的一致性的考虑上,往往需要对某些类要求只能创建一个实例,即「保证类只有一个实例」的设计模式就是单例模式。
比如我们遇到过的各种Manager管理类,各种Factory工厂类;
Spring 框架应用中的 ApplicationContext、数据库中的连接池等也都是单例模式。
本文旨在浅析一下单例模式的写法。
单例模式的8种写法
1. 饿汉式
/**
* 类加载的时候就实例化一个实例,JVM保证线程安全
* 也称饿汉式
* 该方式简单实用
* @author 行百里er
*/
public class Singleton_1 {
private static final Singleton_1 INSTANCE = new Singleton_1();
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_1() {
}
public static Singleton_1 getInstance() {
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
Singleton_1 instance1 = Singleton_1.getInstance();
Singleton_1 instance2 = Singleton_1.getInstance();
System.out.println(instance1 == instance2);
}
}
这是我推荐使用的方法,简单实用,写着安心,用着放心。
2. 意思同第一种,只是写法不同
/**
* 和Singleton_1是同一个意思
* 只是将new的动作放在了代码块里
* 类加载到内存的时候只加载一个实例
* @author 行百里er
*/
public class Singleton_2 {
private static final Singleton_2 INSTANCE;
static {
INSTANCE = new Singleton_2();
}
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_2() {
}
public static Singleton_2 getInstance() {
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
Singleton_2 instance1 = Singleton_2.getInstance();
Singleton_2 instance2 = Singleton_2.getInstance();
System.out.println(instance1 == instance2);
}
}
和第一种写法是同一个意思,只是将new的动作放在了代码块里,类加载到内存的时候只加载一个实例。
3. 懒汉式,用到的时候才实例化
/**
* 懒汉式
* 这种写法虽然达到了用的时候才初始化的目的,但是存在多线程获取实例时相互影响的问题
* @author 行百里er
*/
public class Singleton_3 {
private static Singleton_3 INSTANCE;
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_3() {
}
public static Singleton_3 getInstance() {
if (INSTANCE == null) {
// sleep一下,测试
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_3();
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_3.getInstance().hashCode())).start();
}
}
}
这种写法虽然达到了用的时候才初始化的目的,但是「存在多线程获取实例时相互影响」的问题。
运行结果:
4. 在上一种写法的基础上加synchronized锁,保证线程安全
/**
* lazy loading 懒汉式
*
* 可以用synchronized加锁,但是效率会降低
* @author 行百里er
*/
public class Singleton_4 {
private static Singleton_4 INSTANCE;
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_4() {
}
/**
* 既然lazy loading的写法有线程安全问题,那就加把锁
*/
public static synchronized Singleton_4 getInstance() {
if (INSTANCE == null) {
// 测试,sleep一下,增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_4();
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_4.getInstance().hashCode())).start();
}
}
}
这种方式可行,但会带来效率下降的问题。下面继续“吹毛求疵”。
5. 那就在线程安全的基础上减少锁住的代码数量,「这里有坑」
/**
* lazy loading 懒汉式
* 在加锁的基础上再优化一下,减少加锁代码块的数量
* @author 行百里er
*/
public class Singleton_5 {
private static Singleton_5 INSTANCE;
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_5() {
}
public static Singleton_5 getInstance() {
if (INSTANCE == null) {
//不在方法上加锁而在new的时候才加锁,减少锁的代码,然而这种方式并不行
synchronized (Singleton_5.class) {
// 测试,sleep一下,增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_5();
}
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_5.getInstance().hashCode())).start();
}
}
}
先看运行结果:
说明这种写法看似在线程安全有减少了锁的代码量,其实是达不到“永远”单例的目的的。
「原因分析」:线程A运行完if(INSTANCE == null)
,还没拿到锁时候,线程B也运行到if(INSTANCE == null)
这一句并且拿到锁进行了new实例化,然后线程B释放锁,线程A得到锁继续运行if
语句块里面的内容进行new的过程,这样就出现了不同的实例了。
6. 那就来个双重检查锁(Double Check Locking)吧
/**
* 在加锁的基础上再优化一下,减少加锁代码块的数量---事实证明不可行
* 那就双重检查DCL
* @author 行百里er
*/
public class Singleton_6 {
private static Singleton_6 INSTANCE;
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_6() {
}
public static Singleton_6 getInstance() {
if (INSTANCE == null) { //第一重检查
synchronized (Singleton_6.class) {
if (INSTANCE == null) { //第二重检查
// 测试,sleep一下,增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_6();
}
}
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_6.getInstance().hashCode())).start();
}
}
}
这里,提个问题:「INSTANCE要不要加volatile」?
答案是肯定的。
「volatile」的作用是「保证线程可见性和禁止指令重排序」。在DCL单利模式写法中,volatile主要是用于禁止指令重排序的。因为如果不加volatile关键字,那么可能会出现指令重排序。
假设:一个线程A
执行到 「INSTANCE = new Singleton_6()」 的时候,经过编译器编译,会分成三个指令(注意 INSTANCE 是static的):
给指令申请内存
给成员变量初始化
把这块内存的内容赋值给INSTANCE
既然有值了,那么线程B
上来先进行检查发现已经有值,就不会进入加锁那部分的代码了。
加了「volatile」后,就不允许指令重排序了。所以此时一定是保证线程A
初始化完了才会复制给这个变量。
7. 静态内部类方式
/**
* 静态内部类方式
* JVM保证单例
* 加载外部类时不会加载内部类---也可实现懒加载
* @author 行百里er
*/
public class Singleton_7 {
/**
* 私有的构造方法,其他地方不能new
*/
private Singleton_7() {
}
private static class SingletonHolder {
private static final Singleton_7 INSTANCE = new Singleton_7();
}
public static Singleton_7 getInstance() {
return SingletonHolder.INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_7.getInstance().hashCode())).start();
}
}
}
即可保证单例(虚拟机保证),也能实现懒加载。
如果非要追求完美,那么可以用这种方式。
8. 完美中的完美方式,Enum实现单例
/**
* 枚举单例
* 不仅可以解决线程同步,还可以防止反序列化
*/
public enum Singleton_8 {
INSTANCE;
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程,看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_8.INSTANCE.hashCode())).start();
}
}
}
膜拜一波这种写法!这是Java创始人之一的大神在《Effective Java》这本书中推荐的写法。
小结
虽然单例模式有这么多种写法,但不少是炫技式的花活,有点像孔乙己的“茴”字的N中写法。
这里我们理解其中有些写法的“瑕疵”和其中蕴含的“原理”就可以了。
有道无术,术可成;有术无道,止于术
欢迎大家关注Java之道公众号
好文章,我在看❤️