Java笔记 ·

漫谈单例模式(下)

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

5. 单例代替方案

5.1 静态方法

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

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

}
// 使用示例
long id = IdGenerator.getId();

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);

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();
    }
}

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);
    }
}

注:将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);
    }

}

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");
    }
}

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 扩展

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

相关下载

点击下载

参与评论