计划模式开门之单例模式

单例模式归属于计划模式大类（创建型、结构型、行为型）计划模式中的创建型模式。
一个类只允许创建一个对象（实例）那么这个类就是单例类，这个计划模式就是单例计划模式。单例计划模式的这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该对象，提供了一个全局访问点来访问该实例。
本文从（1）为什么使用单例？（2）如何实现一个单例模式？（3）单例模式可能存在哪些问题？三个方面简单聊聊
为什么使用单例？

处理资源访问辩论

FileWriter本身就是线程安全的，它的内部实现中本身就加了对象级别的锁，因此，在外层调用write()函数的时候，再加对象级别的锁实际上是多此一举。因为不同的Logger对象不共享FileWriter对象，以是，FileWriter对象级别的锁也解决不了数据写入互相覆盖的问题。
那我们该怎么解决这个问题呢？实际上，要想解决这个问题也不难，我们只需要把对象级别的锁，换成类级别的锁就可以了。让所有的对象都共享同一把锁。如许就避免了不同对象之间同时调用log()函数，而导致的日志覆盖问题。

1. public class Logger {
2.   private FileWriter writer;
3.   private static final Logger instance = new Logger();  // 只创建一个实例instance
5.   private Logger() {
6.     File file = new File("/xx/xx/xx.txt");
7.     writer = new FileWriter(file, true); //true表示追加写入
8.   }
9.   
10.   public static Logger getInstance() {
11.     return instance;
12.   }
13.   
14.   public void log(String message) {
15.     writer.write(mesasge);
16.   }
17. }
19. // Logger类的应用示例：
20. public class UserController {
21.   public void login(String username, String password) {
22.     // 业务代码
23.     Logger.getInstance().log(username + "xx");
24.   }
25. }
27. public class OrderController {  
28.   public void create(OrderVo order) {
29.     // 业务代码
30.     Logger.getInstance().log("xx" + order.toString());
31.   }
32. }

复制代码

表示全局唯一类

例如唯一递增号码生成器、调用链路traceId追踪，如果步伐中存在两个重复的对象那么就可能造成重复的ID出现，以是应将ID的生成计划成单例的。

1. import java.util.concurrent.atomic.AtomicLong;
2. public class IdGenerator {
3.   // AtomicLong是一个Java并发库中提供的一个原子变量类型,它将一些线程不安全需要加锁的复合操作封装为了线程安全的原子操作，
4.   // 比如下面会用到的incrementAndGet().
5.   private AtomicLong id = new AtomicLong(0);
6.   private static final IdGenerator instance = new IdGenerator();
7.   private IdGenerator() {}
8.   public static IdGenerator getInstance() {
9.     return instance;
10.   }
11.   public long getId() {
12.     return id.incrementAndGet();
13.   }
14. }
15. // IdGenerator使用举例
16. long id = IdGenerator.getInstance().getId();

复制代码

如何实现一个单例？

饿汉式

在类加载的时候，instance静态实例就已经创建并初始化好了，以是，instance实例的创建过程是线程安全的。不过，如许的实现方式不支持耽误加载（在真正用到IdGenerator的时候，再创建实例）'就是很饥饿，类加载完成的时候 实例也跟着初始化完成了'

1. public class IdGenerator {
2.   private AtomicLong id = new AtomicLong(0);
3.   private static final IdGenerator instance = new IdGenerator(); // 创建单个实例
4.   private IdGenerator() {}
5.   public static IdGenerator getInstance() {   //getInstance返回实例
6.     return instance;
7.   }
8.   public long getId() {   // 方法调用
9.     return id.incrementAndGet();
10.   }
11. }

复制代码

懒汉式

相对于饿汉式来说，懒汉式就是什么时候使用，什么时候再去加载。支持耽误加载

1. public class IdGenerator {
2.   private AtomicLong id = new AtomicLong(0);
3.   private static IdGenerator instance;
4.   private IdGenerator() {}
5.   // 类级别的锁
6.   public static synchronized IdGenerator getInstance() {
7.     if (instance == null) {
8.        // 初始没有 需要再去加载
9.       instance = new IdGenerator();
10.     }
11.     return instance;
12.   }
13.   public long getId() {
14.     return id.incrementAndGet();
15.   }
16. }

复制代码

以上懒汉式在初始化实例的时候加了一把锁，导致函数的并发度很低，如果是简单调用还可以接受
饿汉式与懒汉式的简单比较：
关于这俩的优缺点，也是仁者见仁智者见智。饿汉式有人认为因为不支持耽误加载，如果实例占用资源多（好比占用内存多）或初始化耗时长（好比需要加载各种设置文件），提前初始化实例是一种浪费资源的行为。最好的方法应该在用到的时候再去初始化。
也有人对饿汉式持支持意见认为有问题就要及早暴露。如果需要很多资源，那么等到需要的时候再去加载，比较耗时的加载过程也可能会影响系统的性能（好比，在响应客户端接口请求的时候，做这个初始化操作，会导致此请求的响应时间变长，甚至超时）以下这句是借鉴江湖道友的：
"如果实例占用资源多，按照fail-fast的计划原则（有问题及早暴露），那我们也希望在步伐启动时就将这个实例初始化好。如果资源不够，就会在步伐启动的时候触发报错（好比Java中的 PermGen Space OOM），我们可以立即去修复。如许也能避免在步伐运行一段时间后，忽然因为初始化这个实例占用资源过多，导致系统崩溃，影响系统的可用性。"
双重检测

既支持耽误检测也支持高并发

1. public class IdGenerator {
2.   private AtomicLong id = new AtomicLong(0);
3.   private static IdGenerator instance;
4.   private IdGenerator() {}
5.   public static IdGenerator getInstance() {
6.     if (instance == null) {
7.       synchronized(IdGenerator.class) { // 此处为类级别的锁
8.         if (instance == null) {
9.           instance = new IdGenerator();
10.         }
11.       }
12.     }
13.     return instance;
14.   }
15.   public long getId() {
16.     return id.incrementAndGet();
17.   }
18. }

复制代码

静态内部类

1. public class IdGenerator {
2.   private AtomicLong id = new AtomicLong(0);
3.   private IdGenerator() {}
5.   private static class SingletonHolder{
6.     private static final IdGenerator instance = new IdGenerator();
7.   }
8.   
9.   public static IdGenerator getInstance() {
10.     return SingletonHolder.instance;
11.   }
12.    
13.   public long getId() {
14.     return id.incrementAndGet();
15.   }
16. }

复制代码

当加载IdGenerator时内部类SingletonHolder不会立即创建实例对象，只有调用getInstance()方法时，SingletonHolder才会被加载，这个时候才会创建instance对象。instance的唯一性、创建过程的线程安全性，都由JVM来保证。以是，这种实现方法既保证了线程安全，又能做到耽误加载。
存在的问题？

对OOP的特性支持不太友爱

针对生成唯一的ID自增生成器来说，如果我们想要对不同的业务接纳不同的ID生成算法，好比订单类和用户类接纳不同的算法，那我们就要修改所有效到生成唯一自增ID的地方，改动较大。可能就需要对不同业务给出同步的ID生成器
会隐藏类之间的依赖关系

由于单例类不需要显式创建，不需要依赖参数传递，在代码中直接调用即可。如果代码比较复杂，调用关系比较潜伏就比较难以找出这个类依赖了哪些单例类。
......

以上内容有参考成分，欢迎指导学习，不喜勿喷~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。