漫谈单例模式(下)
在上篇 《漫谈单例模式(上)》一文中介绍了单例定义、使用场景、实现方式以及不足,本篇继续整理针对不足的解决方案以及唯一性的相关讨论与实现等。
5. 单例代替方案
5.1 静态方法
为了保证全局唯一,除了使用单例, 可以用静态方法来实现。但静态方法比单例更加不灵活,比如,它无法支持延迟加载。
public class IdGenerator {
private AtomicLong id = new AtomicLong(0);
// 静态方法实现
public static long getId() {
return id.incrementAndGet();
}
}
// 使用示例
long id = IdGenerator.getId();
2
3
4
5
6
7
8
9
10
5.2 依赖注入
通过依赖注入,将单例生成的对象,作为参数传递给函数(也可以通过构造函数传递给类的成员变量),可以解决单例隐藏类之间依赖关系的问题。
// 旧使用方式
public demoFuntion() {
//...
long id = IdGenerator.getInstance().getId();
//...
}
// 2. 新的使用方式:依赖注入
public demofunction(IdGenerator idGenerator) {
//...
long id = idGenerator.getId();
//...
}
// 外部调用demofunction()的时候,传入idGeneratorIdGenerator
idGenerator = IdGenerator.getInsance();
demofunction(idGenerator);
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
5.3 通过其他方式保证
从根源上出发,类对象的全局唯一性可以通过多种不同的方式来保证:
- 可以通过单例模式来强制保证。
- 可以通过工厂模式、IOC 容器(比如 Spring IOC 容器)来保证。
- 可以通过程序员自己来保证(自己在编写代码的时候自己保证不要创建两个类对象)。
6. 单例模式中的唯一性
6.1 进程唯一
单例模式创建的对象是进程唯一的。
- 使用命令行或者双击运行可执行文件的时候,操作系统会启动一个进程,将这个执行文件从磁盘加载到自己的进程地址空间(可以理解操作系统为进程分配的内存存储区,用来存储代码和数据)。
- 接着,进程就一条一条地执行可执行文件中包含的代码。比如,当进程读到代码中的
User user = new User();
这条语句的时候,它就在自己的地址空间中创建一个 user 临时变量和一个 User 对象。 - 进程之间是不共享地址空间的,如果在一个进程中创建另外一个进程(比如,代码中有一个 fork() 语句,进程执行到这条语句的时候会创建一个新的进程),操作系统会给新进程分配新的地址空间,并且将老进程地址空间的所有内容,重新拷贝一份到新进程的地址空间中,这些内容包括代码、数据(比如 user 临时变量、User 对象)。
- 所以,单例类在老进程中存在且只能存在一个对象,在新进程中也会存在且只能存在一个对象。而且,这两个对象并不是同一个对象,即,单例类中对象的唯一性的作用范围是进程内的,在进程间是不唯一的。
实际上,对于 Java 语言来说,单例类对象的唯一性的作用范围并非进程,而是类加载器(Class Loader),原因在于Java的双亲委派模型。
6.1.1 进程唯一与线程唯一
- “进程唯一”指的是进程内唯一,进程间不唯一。
- “线程唯一”指的是线程内唯一,线程间可以不唯一。
- 实际上,“进程唯一”还代表了线程内、线程间都唯一,这也是“进程唯一”和“线程唯一”的区别之处。
6.2 线程唯一的单例
在代码中,通过一个 HashMap
来存储对象,其中 key 是线程 ID,value 是对象。这样就可以做到,不同的线程对应不同的对象,同一个线程只能对应一个对象。
实际上,Java 语言本身提供了ThreadLocal
工具类,可以更加轻松地实现线程唯一单例。ThreadLocal
底层实现原理也是基于HashMap的方式。
public class IdGenerator6 {
private AtomicLong id = new AtomicLong(0);
private static final ConcurrentHashMap<Long, IdGenerator6> instances
= new ConcurrentHashMap<>();
private IdGenerator6() {}
public static IdGenerator6 getInstance() {
Long currentThreadId = Thread.currentThread().getId();
instances.putIfAbsent(currentThreadId, new IdGenerator6());
return instances.get(currentThreadId);
}
public long getId() {
return id.incrementAndGet();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
6.3 集群环境下的单例
集群相当于多个进程构成的一个集合,“集群唯一”就相当于是进程内唯一、进程间也唯一。即,不同的进程间共享同一个对象,不能创建同一个类的多个对象。
- 需要把这个单例对象序列化并存储到外部共享存储区(比如文件)。
- 进程在使用这个单例对象的时候,需要先从外部共享存储区中将它读取到内存,并反序列化成对象,然后再使用,使用完成之后还需要再存储回外部共享存储区。
- 为了保证任何时刻,在进程间都只有一份对象存在,一个进程在获取到对象之后,需要对对象加锁,避免其他进程再将其获取。
- 在进程使用完这个对象之后,还需要显式地将对象从内存中删除,并且释放对对象的加锁。
/**
* 集群唯一
*
* [设计模式之美](https://windcoder.com/go/JKDesignPattern)中仅提供了伪代码。
* 这里根据伪代码尝试做了一个基于Redis的简单实现。
* 代码本身没做测试,仅做一种实现思路参考,请勿直接粘贴复制到生产环境。
*
* Redisson 操作redis实现单例对象的序列化存储与反序列化读取。
* Redisson 实现Redis分布式锁,用于取出前的加锁,与操作后的释放锁。
*
* 关于Redisson为何配置自定义序列化与反序列化的问题, 可以参考:
* [redisson如何序列化](https://www.php.cn/redis/436670.html)
*/
public class IdGenerator7 implements Serializable {
private AtomicLong id = new AtomicLong(0);
private static IdGenerator7 instance;
static RedissonClient redisson = getRedissonClient();
static RLock lock = redisson.getLock("anyLock");
private IdGenerator7() {}
public synchronized static IdGenerator7 getInstance() {
if (instance == null) {
lock.lock();
RBucket<IdGenerator7> bucket = redisson.getBucket("IdGenerator");
//如果key存在,就设置key的值为新值value
//如果key不存在,就设置key的值为value
// https://www.pianshen.com/article/5465125503/
bucket.set(new IdGenerator7());
instance = bucket.get();
}
return instance;
}
public synchronized void freeInstance() {
RBucket<IdGenerator7> bucket = redisson.getBucket("IdGenerator");
bucket.set(new IdGenerator7());
instance = null; //释放对象
lock.unlock();
}
public long getId() {
return id.incrementAndGet();
}
// 单例模式变可序列化必须提供该方法。
private Object readResolve() {
return instance;
}
/**
* 读取Redisson关于Redis的相关配置,生成Redisson对象。
*
* 这里仅为了方便实现与展示集群唯一的示例。
* @return
*/
private static RedissonClient getRedissonClient() {
Config config = null;
try {
config = Config.fromYAML(new File("classpath:redisson.yaml"));
} catch (IOException e) {
e.printStackTrace();
}
return Redisson.create(config);
}
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
注:将Singleton类变成可序列化的(Serializable)仅**在声明中加上 implements Serializable
**是不够的的。为了维护和保证Singleton,必须声明所有实例域都是瞬时(transient)的,并提供一个readResolve
方法。否则每次反序列化一个序列化的实例时,都会创建一个新的实例。
6.4 多例模式
核心是通过一个 Map
来存储对象类型和对象之间的对应关系,来控制对象的个数。
6.4.1 一个类创建有限多个对象
“单例”指的是,一个类只能创建一个对象。对应地,“多例”指的就是,一个类可以创建多个对象,但是个数是有限制的,比如只能创建 3 个对象。
public class IdGenerator8 {
private long serverNo;
private String serverAddress;
private static final int SERVER_COUNT = 3;
private static final ConcurrentHashMap<Long, IdGenerator8> instances
= new ConcurrentHashMap<>();
static {
instances.put(1L, new IdGenerator8(1L, "192.134.22.138:8080"));
instances.put(2L, new IdGenerator8(2L, "192.134.22.139:8080"));
instances.put(3L, new IdGenerator8(3L, "192.134.22.140:8080"));
}
private IdGenerator8(long serverNo, String address) {
this.serverNo = serverNo;
this.serverAddress = address;
}
public IdGenerator8 getInstance(long serverNo) {
return instances.get(serverNo);
}
public IdGenerator8 getRandomInstance() {
Random r = new Random();
int no = r.nextInt(SERVER_COUNT)+1;
return instances.get(no);
}
}
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
6.4.2 同类型创建一个,不同类型创建多个对象
“多例”还有一种理解方式:同一类型的只能创建一个对象,不同类型的可以创建多个对象。
这种多例模式的理解方式有点类似工厂模式。它跟工厂模式的不同之处是,多例模式创建的对象都是同一个类的对象,而工厂模式创建的是不同子类的对象。
public class IdGenerator9 {
private static final ConcurrentHashMap<String, IdGenerator9> instances
= new ConcurrentHashMap<>();
private IdGenerator9() {}
public static IdGenerator9 getInstance(String name) {
instances.putIfAbsent(name, new IdGenerator9());
return instances.get(name);
}
public static void main(String[] args) {
IdGenerator9 i1 = IdGenerator9.getInstance("User.class");
IdGenerator9 i2 = IdGenerator9.getInstance("User.class");
IdGenerator9 i3 = IdGenerator9.getInstance("Order.class");
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
7. 附录
7.1 是否应该延迟加载
7.1.1 应该延迟
如果实例占用资源多(比如占用内存多)或初始化耗时长(比如需要加载各种配置文件),提前初始化实例是一种浪费资源的行为。
7.1.2 不应该延迟
如果初始化耗时长,那我们最好不要等到真正要用它的时候,才去执行这个耗时长的初始化过程,这会影响到系统的性能(比如,在响应客户端接口请求的时候,做这个初始化操作,会导致此请求的响应时间变长,甚至超时)。采用饿汉式实现方式,将耗时的初始化操作,提前到程序启动的时候完成,这样就能避免在程序运行的时候,再去初始化导致的性能问题。
如果实例占用资源多,按照 fail-fast 的设计原则(有问题及早暴露),那我们也希望在程序启动时就将这个实例初始化好。如果资源不够,就会在程序启动的时候触发报错(比如 Java 中的 PermGen Space OOM),我们可以立即去修复。这样也能避免在程序运行一段时间后,突然因为初始化这个实例占用资源过多,导致系统崩溃,影响系统的可用性。
7.2 进程 (thread) 和线程 (process) 的区别
- 根本区别:进程是资源分配的最小单位,线程是CPU调度的最小单位。
- 地址空间:进程之间是独立的地址空间,同一进程的线程共享本进程的地址空间。
- 执行过程:每个独立的进程都有一个程序运行的入口、顺序执行序列和程序入口。但是线程不能独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。
- 通信:进程之间的通信需要以通信的方式(IPC)进行,同一进程下的线程共享全局变量、静态变量等数据资源,从而线程之间的通信更方便。
- 健壮:多进程程序更健壮,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,一个线程死掉就等于整个进程死掉。
- 效率:进程切换时,耗费资源较大,效率要差一些
7.2 参考资料
- 设计模式之美
- 《Effective Java第三版》
- redisson-中文文档
- 一道面试题:说说进程和线程的区别
- 线程与进程的区别
- 线程与进程的区别
7.3 扩展
除特别注明外,本站所有文章均为 Windcoder网 原创,转载请注明出处来自: danlimoshixia

No Data