0%

单例模式

单例模式是最简单的设计模式之一,属于创建型模式,它提供了一种创建对象的方式,确保只有单个对象被创建。这个设计模式主要目的是想在整个系统中只能出现类的一个实例,即一个类只有一个对象。
单例模式的解决的痛点就是节约资源,节省时间从两个方面看:

  1. 由于频繁使用的对象,可以省略创建对象所花费的时间,这对于那些重量级的对象而言,是很重要的.
  2. 因为不需要频繁创建对象,我们的GC压力也减轻了,而在GC中会有STW(stop the world),从这一方面也节约了GC的时间

枚举单例

1
2
3
public enum EnumTheSun {
INSTANCE;
}

内部类单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public final class InitializingOnDemandHolderTheSun {

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

/**
* 提供实例方法
*
* @return 单例实例
*/
public static InitializingOnDemandHolderTheSun getInstance() {
return HelperHolder.INSTANCE;
}

/**
* 提供懒加载单例实例
*/
private static class HelperHolder {
private static final InitializingOnDemandHolderTheSun INSTANCE =
new InitializingOnDemandHolderTheSun();
}
}

静态属性单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public final class TheSun {

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

/**
* 静态单例实例
*/
private static final TheSun INSTANCE = new TheSun();

/**
* 提供实例方法
*
* @return 单例实例
*/
public static TheSun getInstance() {
return INSTANCE;
}
}

双验证单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public final class ThreadSafeDoubleCheckTheSun {

private static volatile ThreadSafeDoubleCheckTheSun instance;

private static boolean flag = true;

/**
* 私有构造函数
*/
private ThreadSafeDoubleCheckTheSun() {
// 防止通过反射调用实例化
if (flag) {
flag = false;
} else {
throw new IllegalStateException("Already initialized.");
}
}

/**
* 提供实例方法
*
* @return 单例实例
*/
public static ThreadSafeDoubleCheckTheSun getInstance() {
// 局部变量将性能提高25%
var result = instance;
// 检查是否初始化了单例实例。
// 如果它已初始化,那么我们可以返回实例。
if (result == null) {
// 它未初始化,但我们无法确定,因为其他线程可能会同时初始化它。
// 所以为了确保我们需要锁定一个对象以获得互斥。
synchronized (ThreadSafeDoubleCheckTheSun.class) {
// 再次将实例分配给局部变量,以检查当前线程被阻止进入锁定区域时是否由其他线程初始化。
// 如果它已经初始化,那么我们可以返回先前创建的实例
result = instance;
if (result == null) {
// 实例仍然没有初始化,因此我们可以安全地(没有其他线程可以进入此区域)
// 创建一个实例并将其作为我们的单实例。
instance = result = new ThreadSafeDoubleCheckTheSun();
}
}
}
return result;
}
}

懒加载单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public final class ThreadSafeLazyLoadedTheSun {

private static ThreadSafeLazyLoadedTheSun instance;

private ThreadSafeLazyLoadedTheSun() {
// 防止通过反射调用实例化
if (instance == null) {
instance = this;
} else {
throw new IllegalStateException("Already initialized.");
}
}

/**
* 实例只有在第一次调用时才被创建。延迟加载
*/
public static synchronized ThreadSafeLazyLoadedTheSun getInstance() {
if (instance == null) {
instance = new ThreadSafeLazyLoadedTheSun();
}

return instance;
}
}