单例模式-只有一个实例

介绍

单例模式(Singleton Pattern)是一个比较简单的设计模式,属于创建型模式。其定义为

确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例

在系统中,单例模式要求一个单例对象只能有一个实例,这类对象如果有多个实例就可能会产生一些问题,如:资源消耗过多,处理结果不一致等,一般单例会有以下使用场景

  • 生成唯一 序列号
  • 整个项目的共享访问点或共享数据,如Web页面计数器
  • 创建一个对象实例需要消耗过多资源,如I/O和数据库连接等

在Java中,一个单例对象在一个JVM中,只会有一个实例存在。以下是单例模式结构图

单例模式结构图

  • 有一个该单例对象的静态成员变量
  • 私有的构造函数,只能被自身实例化
  • 提供一个静态公共方法实例化对象,并访问该对象实例

单例模式实现

单例模式有两种实现方式:

  • 饿汉式
  • 懒汉式(延迟加载)

饿汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* 饿汉式单例
*/
public class Singleton1 {
// 静态成员变量,在静态初始化时便实例化对象
private static final Singleton1 singleton = new Singleton1();
// 构造私有
private Singleton1(){
}
public static Singleton1 getSingletonInstance(){
return singleton;
}
}

饿汉式指的是,在类加载的时候便实例化了该单例对象,不管有没有使用,先创建了再说。这种方式是可以保证线程安全的,但是如果该对象一直没有被使用,就浪费了空间资源。

但是对于一些空间占用较大、或是只在某些特定场景才使用的单例,我们会想要在第一次使用的时候才去实例化,这时,就需要懒汉式的延迟加载

懒汉式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
* 懒汉式单例(非线程安全)
*/
public class Singleton2 {
private static Singleton2 singleton;
private Singleton2(){}
// 获取实例
public static Singleton2 getSingletonInstance(){
if(singleton == null){
singleton = new Singleton2();
}
return singleton;
}
}

从上面代码可以看出,懒汉式饿汉式在于单例对象的创建时机。饿汉式是在类加载时便实例化对象,调用时无须判断直接返回即可;而懒汉式是在第一次调用时实例化,并且每次调用都需要判断是否已经实例化

但是上面的这种方式在多线程下是不安全的,多个线程同时访问getSingletonInstance()时,可能会创建多个实例,便不再是单例了。那怎么解决线程安全的问题呢?首先我们可能会想到对getSingletonInstance()方法加上synchronized关键字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
* 懒汉式单例(synchronized关键字线程安全)
*/
public class Singleton3 {
private static Singleton3 singleton;
private Singleton3(){}
// 获取实例
public static synchronized Singleton3 getSingletonInstance(){
if(singleton == null){
singleton = new Singleton3();
}
return singleton;
}
}

getSingletonInstance()方法加上了同步锁,增加了获取实例的时间消耗,且在多线程下可能会发生阻塞。但其实我们并不想每次获取实例的时候都去加上锁,只是想在第一次调用创建对象时保证线程安全即可

双重校验锁(DCL)

getSingletonInstance()方法加上锁,确实能保证线程安全,却存在性能的问题。是不是要必要对整个方法加锁?还是当我检查到实例还没有创建,才去同步

双重校验锁(double-checked locking,DCL)是能解决这个问题的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
* 双重校验锁(double-checked locking,DCL)
*/
public class Singleton4 {
/**
* 成员变量这里会加上关键字 volatile,目的是为了防止指令重排序
*/
private static volatile Singleton4 singleton;
private Singleton4(){}
// 获取实例
public static Singleton4 getSingletonInstance(){
// 第一次校验,没有实例化才进入同步代码块
if(singleton == null){
synchronized (Singleton4.class){
// 进入同步代码块后,再判断,如果为空才创建实例
if(singleton == null){
singleton = new Singleton4();
}
}
}
return singleton;
}
}

不对方法加上锁,只对创建实例的代码加锁即可。方法中会有两次判空的操作,第一次是为了不必要的同步,为null才进入同步代码块,第二次是进入同步代码块后判断为null才创建实例

注意:这里的成员变量加上了volatile关键字

使用volatile可以保证数据的可见性,不过synchronized也是能保证同步数据的可见性的,这里使用volatile更多的目的是为了禁止Java指令重排序

静态内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* 静态内部类
*/
public class Singleton5 {
private Singleton5(){}

// 获取实例
public static Singleton5 getSingletonInstance(){
return SingletonHolder.SINGLETON;
}

/**
* 内部类,JVM在类加载的时候,是互斥的,可以保证线程安全
*/
private static class SingletonHolder{
private static final Singleton5 SINGLETON = new Singleton5();
}
}

JVM在类加载的时候是会保证数据同步的,我们可以通过内部类来创建单例对象。第一次加载Singleton5时并不会加载内部类,不去使用内部类的时候,该内部类就不会加载。只有第一次调用getSingletonInstance()方法,会去加载内部类并实例化单例对象,这样就可以做到延迟加载和线程安全了

枚举方式

使用枚举方式来实现单例是非常简洁的,支持序列化机制,绝对防止多次实例化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
* 枚举方式
*/
public enum Singleton6 {

/**
* 枚举方式实现单例
*/
SINGLETON;

public void handle() {
// to do something
}
}

该单例的使用方法

1
2
3
4
5
6
7
8
9
public class SingletonDemo {

@Test
public void test(){
// 枚举方式
Singleton6 singleton = Singleton6.SINGLETON;
singleton.handle();
}
}