Java笔记··By/蜜汁炒酸奶

漫谈单例模式（下）

设计模式单例模式
882 0

在上篇 《漫谈单例模式（上）》一文中介绍了单例定义、使用场景、实现方式以及不足，本篇继续整理针对不足的解决方案以及唯一性的相关讨论与实现等。

5. 单例代替方案

5.1 静态方法

为了保证全局唯一，除了使用单例， 可以用静态方法来实现。但静态方法比单例更加不灵活，比如，它无法支持延迟加载。

public class IdGenerator {
    private AtomicLong id = new AtomicLong(0);
    // 静态方法实现
    public static long getId() {
        return id.incrementAndGet();
    }

}
// 使用示例
long id = IdGenerator.getId();
1
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);
1
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();
    }
}
1
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);
    }
}
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
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);
    }

}
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

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");
    }
}
1
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 参考资料

7.3 扩展

进程与线程的一个简单解释

预览
除特别注明外，本站所有文章均为 windcoder 原创，转载请注明出处来自： danlimoshixia
License CC BY-SA 4.0 以商业目的使用本网站原创内容需获许可，非商业目的使用授权遵循CC BY-NC 4.0
Loading comments...
0 条评论

暂无数据

example
预览