设计模式之美笔记8
记录学习王争的设计模式之美 课程 笔记和练习代码，以便回顾复习，共同进步
文章目录
- 单例模式
- 1. 为什么要使用单例
- 2. 应用场景
- 实战案例1：处理资源访问冲突
- 实战案例2：表示全局唯一类
- 3. 如何实现单例
- 1. 饿汉式
- 2. 懒汉式
- 3. 双重检测
- 4. 静态内部类
- 5. 枚举
- 4. 单例存在的问题
- 1. 对OOP特性的支持不友好
- 2. 单例会隐藏类之间的依赖关系
- 3. 单例对代码的扩展性不友好
- 4. 单例对代码的可测试性不友好
- 5. 单例不支持有参构造函数
- 5. 有什么替代解决方案
- 6. 如何理解单例模式中的唯一性
- 7. 如何实现线程唯一的单例
- 8. 如何实现集群环境下的单例
- 9.如何实现一个多例模式
单例模式
问题：
- 为什么要使用单例
- 单例存在哪些问题
- 单例与静态类的区别
- 有什么替代的解决方案
1. 为什么要使用单例
单例设计模式singleton design pattern，一个类只允许创建一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫单例设计模式。
2. 应用场景
为什么需要单例模式？能解决哪些问题？
实战案例1：处理资源访问冲突
public class Logger {
private FileWriter writer;
public Logger(){
File file = new File("xxx/xx/log.txt");
writer = new FileWriter(file,true);//true表示追加写入
}
public void log(String message){
writer.write(message);
}
}
// logger类的应用示例：
public class UserController {
private Logger logger = new Logger();
public void login(String username,String password){
//...省略业务逻辑代码...
logger.log(username+" logined!");
}
}
public class OrderController {
private Logger logger = new Logger();
public void create(OrderVo order){
//...省略业务逻辑代码...
logger.log("Created an order: "+order.toString());
}
}
上述代码中，所有的日志都写入到同一个文件中。在UserController和OrderController中，分别创建两个Logger对象。在web容器的servlet多线程环境下，如果两个servlet线程同时执行login()和create()两个方法，并同时写日志到log.txt中，可能存在日志信息相互覆盖的情况。
为什么相互覆盖？可以类比理解。多线程下，如果两个线程同时给共享变量加1，最后结果可能并不是加2，而是只加了1，因为是竞争资源。同理，这里的log.txt文件也是竞争资源，可能存在相互覆盖。
如何解决？首先想到加锁。给log()方法加互斥锁（java的synchronized关键字）。同一时刻只允许一个线程调用执行log()方法。
public void log(String message){
synchronized(this){
writer.write(message);
}
}
但是这样真的能解决多线程写入日志时互相覆盖的问题吗？不能，因为锁是对象级别的锁，不同的对象之间不共享这把锁。不同线程下，通过不同的对象调用执行log()方法，锁不起作用。
其实，FileWriter本身就是线程安全的，内部实现本身就加了对象级别的锁。再加对象锁多此一举。
那如何解决呢？只需要把对象锁换成类级别的锁即可。
public void log(String message){
synchronized(Logger.class){//类级别的锁
writer.write(message);
}
}
此外，解决资源竞争问题的方法还有很多，分布式锁就是常听到的解决方案。不过，实现一个安全可靠、无bug、高性能的分布式锁，不容易。此外，并发队列（如Java的BlockingQueue）也可解决该问题。多个线程同时往并发队列写日志，一个单独的线程负责将并发队列的数据，写入到日志文件。也稍微复杂。
相较来说，单例模式就简单多了。相对于类级别的锁的好处：不用创建那么多Logger对象，一方面节省内存空间，另一方面节省文件句柄（对OS说，文件句柄也是资源，不能随便浪费）。
将Logger设计为单例类，程序中只允许创建一个Logger对象，所有的线程共享使用的这个Logger对象，共享一个FileWriter对象。而FileWriter本身就是对象级别的线程安全的，避免多线程下写日志互相覆盖。
重新设计后：
public class Logger {
private FileWriter writer;
private static final Logger instance = new Logger();
public Logger(){
File file = new File("xxx/xx/log.txt");
writer = new FileWriter(file,true);//true表示追加写入
}
public static Logger getInstance(){
return instance;
}
public void log(String message){
writer.write(message);
}
}
// logger类的应用示例：
public class UserController {
public void login(String username,String password){
//...省略业务逻辑代码...
Logger.getInstance().log(username+" logined!");
}
}
实战案例2：表示全局唯一类
从业务上说，如果有些数据在系统中只应保存一份，比较适合设计为单例类，如配置信息类。在系统中，只有一个配置文件，被加载到内存后，以对象的形式存在，理应只有一份。还有，唯一递增ID号码生成器，如果程序有两个对象，会存在生成重复ID的情况，应设计为单例。
public class IdGenerator {
//AtomicLong是一个java并发库提供的原子变量类型
//将一些线程不安全需要加锁的复合操作封装为线程安全的原子操作，如下面的incrementAndGet()
private AtomicLong id = new AtomicLong(0);
private static final IdGenerator instance = new IdGenerator();
private IdGenerator(){}
public static IdGenerator getInstance(){
return instance;
}
public long getId(){
return id.incrementAndGet();
}
}
//使用举例
long id = IdGenerator.getInstance().getId();
当然，这两个代码实例Logger、IdGenerator设计的都并不优雅，如何改造留到之后处理。
3. 如何实现单例
有几种简单的经典方式，要实现一个单例，需要关注的无非几个方面：
- 构造函数是要private权限的，才能避免外部new创建实例
- 考虑对象创建时的线程安全问题
- 考虑是否支持延迟加载
- 考虑getInstance()性能是否高（是否加锁）
1. 饿汉式
较为简单，类加载时，instance静态实例就已经创建并初始化好了，instance实例创建过程是线程安全的。不过不支持延迟加载。
public class IdGenerator {
private AtomicLong id = new AtomicLong(0);
private static final IdGenerator instance = new IdGenerator();
private IdGenerator(){}
public static IdGenerator getInstance(){
return instance;
}
public long getId(){
return id.incrementAndGet();
}
}
饿汉式初始化耗时长，采用饿汉式，将耗时的初始化操作，提前到程序启动时完成，避免在程序运行时，再去初始化导致性能问题。
如果实例占用资源多，按照fail-fast的设计原则，也希望在程序启动时，就将实例初始化好。如果资源不够，尽早报错，可以立即去修复。
2. 懒汉式
优势是支持延迟加载
public class IdGenerator {
private AtomicLong id = new AtomicLong(0);
private static IdGenerator instance;
private IdGenerator(){}
public static synchronized IdGenerator getInstance(){
if (instance == null){
instance = new IdGenerator();
}
return instance;
}
public long getId(){
return id.incrementAndGet();
}
}
缺点是给getInstance()加了锁，导致并发度很低。如果该单例被频繁使用，会导致频繁的加锁、释放锁，不可取。
3. 双重检测
既支持延迟加载，又支持高并发。只要instance被创建后，即使再调用getInstance()方法也不会在进入加锁逻辑。
public class IdGenerator {
private AtomicLong id = new AtomicLong(0);
private static IdGenerator instance;
private IdGenerator(){}
public static synchronized IdGenerator getInstance(){
if (instance == null){
synchronized (IdGenerator.class){
if (instance == null){
instance = new IdGenerator();
}
}
}
return instance;
}
public long getId(){
return id.incrementAndGet();
}
}
这种实现方式有些问题，因为指令重排，可能导致IdGenerator对象被new出来，并赋值给instance后，还没来得及初始化（执行构造函数的代码逻辑），就被另一个线程使用。
解决这个问题，需要给instance成员变量加上volatile关键字，禁止指令重排。当然，只有低版本的java才有该问题，高版本的java已经在jdk内部解决该问题。
4. 静态内部类
比双检锁更简单的方法，利用java的静态内部类。
public class IdGenerator {
private AtomicLong id = new AtomicLong(0);
private IdGenerator(){}
private static class SingletonHolder{
private static final IdGenerator instance = new IdGenerator();
}
public static IdGenerator getInstance(){
return SingletonHolder.instance;
}
public long getId(){
return id.incrementAndGet();
}
}
SingletonHolder是个静态内部类，当外部类IdGenerator被加载时，并不会创建SingletonHolder实例对象。只有调用getInstance()时，SingletonHolder才会被加载，这时才会创建instance。instance的唯一性、创建过程的线程安全型都有jvm保证。既保证线程安全，又能延迟加载。
5. 枚举
最简单，就是枚举，保证实例创建的线程安性和实例的唯一性。
public enum IdGenerator {
INSTANCE;
private AtomicLong id = new AtomicLong(0);
public long getId(){
return id.incrementAndGet();
}
}
4. 单例存在的问题
1. 对OOP特性的支持不友好
OOP的四大特性：封装、抽象、继承和多态。单例对于抽象、继承和多态的支持都不好。
IdGenerator的使用方式违背了基于接口而非实现的设计原则。也就违背了广义的OOP的抽象特性。如果之后我们希望对不同的业务采用不同的ID生成算法。如订单ID和用户ID采用不同的ID生成器来生成。为应对这个需求变化，需要修改所有用到IdGenerator的地方，改动很大。
此外，对于继承、多态支持也不友好。单例类理论上可以被继承、实现多态，但实现很奇怪，导致代码可读性变差。因此，如果选择将某个类设计为单例类，意味着放弃继承和多态，损失了应对未来需求变化的扩展性。
2. 单例会隐藏类之间的依赖关系
代码可读性非常重要，通过构造方法、参数传递等方式声明的类之间的依赖关系，通过查看方法的定义，很容易识别。但是，单例类不需要显式创建、不需要依赖参数传递，在方法中直接调用即可。如果代码复杂，调用关系非常隐蔽。
3. 单例对代码的扩展性不友好
单例只有一个对象实例，如果有天想要创建两个实例或多个实例，对代码有较大的改动。
可能会说，会有这种需求吗？既然大部分情况下都用来表示全局类，怎么会需要两个或多个实例呢？
实际需求并不少见，以数据库连接池为例。设计初期，觉得应该只有一个数据库连接池，方便控制对数据库连接资源的消耗。设计为单例类。之后发现有些SQL语句运行很慢，执行时长期占用连接资源，导致其他事情了请求无法响应。希望将慢SQL和其他SQL隔离开，需要创建两个数据库连接池，避免慢SQL影响其他SQL的执行。
如果设计为单例类，显然无法适应这样的需求变更。所以，数据库连接池、线程池这类资源池，最好不要设计为单例类。实际上，一些开源的数据库连接池、线程池也确实没有设计为单例类。
4. 单例对代码的可测试性不友好
如果单例类依赖比较重的外部资源，如DB，写单元测试时，希望mock的方式替换，但单例这种硬编码的使用方式，无法mock替换。
此外，如果单例类持有成员变量（如IdGenerator的id成员变量），实际上相当于一种全局变量，被所有的代码共享。如果这个全局变量是个可变全局变量，也就是说，它的成员变量可被修改，编写单元测试时，还要注意不同测试用例之间，修改了单例类中的同一个成员变量的值，导致测试结果相互影响的问题。
5. 单例不支持有参构造函数
如创建一个连接池的单例对象，没法通过参数指定连接池的大小。这种有哪些解决方案呢？
第一种：创建完实例后，再调用init()方法传递参数。需要注意，在使用这个单例类时，先调用init()方法，才能调用getInstance()方法，否则代码会抛异常。
public class Singleton {
private static Singleton instance = null;
private final int paramA;
private final int paramB;
private Singleton(int paramA,int paramB){
this.paramA = paramA;
this.paramB = paramB;
}
public static Singleton getInstance(){
if (instance==null){
throw new RuntimeException("Run init() first.");
}
return instance;
}
public synchronized static Singleton init(int paramA,int paramB){
if (instance==null){
throw new RuntimeException("Singleton has been created.");
}
instance = new Singleton(paramA,paramB);
return instance;
}
}
Singleton.init(10,50);//先init，再使用
Singleton singleton = Singleton.getInstance();
第二种：将参数放到getInstance()方法中
public class Singleton {
private static Singleton instance = null;
private final int paramA;
private final int paramB;
private Singleton(int paramA,int paramB){
this.paramA = paramA;
this.paramB = paramB;
}
public synchronized Singleton getInstance(int paramA,int paramB){
if (instance==null){
instance = new Singleton(paramA,paramB);
}
return instance;
}
}
Singleton singleton = Singleton.getInstance(10,50);
不过，上面代码稍有点问题，如果如下执行两次getInstance()方法，获取到的singleton1和singleton2的paramA和paramB都是10和50，也就是第二次的参数没有起作用。
Singleton singleton = Singleton.getInstance(10,50);
Singleton singleton = Singleton.getInstance(20,30);
第三种：将参数放到另一个全局变量中，具体代码如下。Config是一个存储了paramA和paramB值的全局变量。里面的值既可以像下面的代码通过静态常量定义，也可从配置文件加载得到。这种方式最值得推荐。
public class Config {
public static final int PARAM_A = 123;
public static final int PARAM_B = 123;
}
public class Singleton {
private static Singleton instance = null;
private final int paramA;
private final int paramB;
private Singleton(){
this.paramA = Config.PARAM_A;
this.paramB = Config.PARAM_B;
}
public synchronized Singleton getInstance(){
if (instance==null){
instance = new Singleton();
}
return instance;
}
}
5. 有什么替代解决方案
为了表示全局唯一，除了使用单例，还可以使用静态方法实现。如
public class IdGenerator {
private static AtomicLong id = new AtomicLong(0);
public static long getId(){
return id.incrementAndGet();
}
}
//使用举例
long id = IdGenerator.getId();
不过静态方法这种实现，更不灵活，还有另外一种方法：
//1. 老的使用方式
public demoFunction(){
//...
long id = IdGenerator.getInstance().getId();
//...
}
//2. 新的使用方式：注入依赖
public demoFunction(IdGenerator idGenerator){
long id = idGenerator.getId();
}
//外部调用demoFunction()时，传入idGenerator
IdGenerator idGenerator = IdGenerator.getInstance();
demoFunction(idGenerator);
新的使用方式，将单例生成的对象，作为参数传递给方法（也可通过构造方法传递给类的成员变量），可以解决单例隐藏类之间依赖关系的问题。不过对于单例的其他问题如OOP特性支持、扩展性、可测试性不好等问题，还是无法解决。
实际上，要解决这些问题，需要从根本上，寻找其他方式实现全局唯一类。实际上，类对象的全局唯一性可通过多种不同的方式来保证。既可以通过单例模式强制保证，也可通过工厂模式、IOC容器（如spring IOC容器）保证，还可通过程序员自己保证（自己编写代码时，保证不创建两个类对象）。类似于java的内存对象的释放由JVM负责，而C++由程序员自己负责一样。
6. 如何理解单例模式中的唯一性
单例的定义：一个类只允许创建唯一一个对象（或者实例），那这个类就是一个单例类，这种设计模式就叫单例模式。
对象的唯一性的作用范围是什么呢？是线程还是进程唯一？答案是后者。
单例类中对象的唯一性的作用范围是进程内，在进程间不唯一。
7. 如何实现线程唯一的单例
什么是线程唯一的单例，线程唯一和进程唯一的区别
进程唯一指的是进程内唯一，进程间不唯一。线程唯一指的线程内唯一，线程间可以不唯一。而进程唯一还代表了线程内、线程间都唯一。
线程唯一的单例的代码实现很简单。通过一个HashMap存储对象，key是线程ID，value是对象。这样就能不同线程对应不同的对象，同一个线程只能对应一个对象。实际上，java语言本身提供了ThreadLocal工具类，可更轻松的实现线程唯一单例。ThreadLocal底层实现原理也是基于HashMap
public class IdGenerator {
private AtomicLong id = new AtomicLong(0);
private static final ConcurrentHashMap<Long,IdGenerator> instances = new ConcurrentHashMap<>();
private IdGenerator(){}
public static IdGenerator getInstance(){
Long currentThreadId = Thread.currentThread().getId();
instances.putIfAbsent(currentThreadId,new IdGenerator());
return instances.get(currentThreadId);
}
public long getId(){
return id.incrementAndGet();
}
}
8. 如何实现集群环境下的单例
什么是集群唯一的单例
集群相当于多个进程构成的一个集合，集群唯一就相当于进程内唯一，进程间也唯一。不同的进程间共享同一个对象，不能创建同一个类的多个对象。
如果严格按照不同的进程间共享同一个对象来实现，那集群唯一的单例实现起来有点难度。
具体说，需要把这个单例对象序列化并存储到外部共享存储区（如文件），进程在使用该单例对象时，先从外部共享存储区将其读取到内存，并反序列化为对象，再使用，用完后再存储回外部共享存储区。
为保证任何时刻，在进程间都只有一份对象存在，一个进程在获取到对象后，需要对对象加锁，避免其他进程再将其获取，用完后，显式的把对象从内存中删除，并释放对象的锁。
public class IdGenerator {
private AtomicLong id = new AtomicLong(0);
private static IdGenerator instance;
private static SharedObjectStorage storage = FileSharedObjectStorage();
private static DistributedLock lock = new DistributedLock();
private IdGenerator(){}
public synchronized static IdGenerator getInstance(){
if (instance == null){
lock.lock();
instance = storage.load(IdGenerator.class);
}
return instance;
}
public synchronized void freeInstance(){
storage.save(this,IdGenerator.class);
instance = null;//释放对象
lock.unlock();
}
public long getId(){
return id.incrementAndGet();
}
}
//使用举例
IdGenerator idGenerator = IdGenerator.getInstance();
long id = idGenerator.getId();
IdGenerator.freeInstance();
9.如何实现一个多例模式
多例，一个类可以创建多个对象，但是个数是有限制的，如智能创建3个对象，如下：
public class BackendServer {
private long serverNo;
private String serverAddress;
private static final int SERVER_COUNT = 3;
private static final Map<Long,BackendServer> serverInstances = new HashMap<>();
static {
serverInstances.put(1L,new BackendServer(1L,"192.134.11.111:8080"));
serverInstances.put(2L,new BackendServer(2L,"192.134.11.112:8080"));
serverInstances.put(3L,new BackendServer(3L,"192.134.11.113:8080"));
}
private BackendServer(long serverNo,String serverAddress){
this.serverNo = serverNo;
this.serverAddress = serverAddress;
}
public BackendServer getInstance(long serverNo){
return serverInstances.get(serverNo);
}
public BackendServer getRandomInstance(){
Random r = new Random();
int no = r.nextInt(SERVER_COUNT)+1;
return serverInstances.get(no);
}
}
实际上，对于多例，还有一种理解：同一类型的只能创建一个对象，不同类型的可创建多个对象。这里的“类型”如何理解？
举例，在下面代码中，logger name就是刚才说的类型，同一个logger name获取到的对象实例是相同的，不同的logger name获取到的对象实例是不同的。
public class Logger {
private static final ConcurrentHashMap<String,Logger> instances = new ConcurrentHashMap<>();
private Logger(){}
public static Logger getInstance(String loggerName){
instances.putIfAbsent(loggerName,new Logger());
return instances.get(loggerName);
}
public void log(){
//...
}
}
// l1==l2 l1!=l3
Logger l1 = Logger.getInstance("User.class");
Logger l2 = Logger.getInstance("User.class");
Logger l3 = Logger.getInstance("Order.class");
这种多例模式的理解方式类似工厂模式。不同之处是，多例模式创建的对象都是同一个类的对象，而工厂模式创建的对象是不同子类的对象。此外，枚举类型也相当于多例模式，一个类型只能对应一个对象，一个类可创建多个对象。
对于java语言，单例类对象的唯一性的作用范围不是进程，而是类加载器class loader。为什么？
java中两个类来源于同一个class文件，被同一个虚拟机加载，只要加载他们的类加载器不同，那这两个类就必定不相等。
单例类对象的唯一性前提是必须保证该类被同一个类加载器加载。