title: 设计模式之单例模式
date: 2020-11-28 00:12:03
tags: java GOF 设计模式
一、应用场景
单例模式是创建型模式，是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局的访问点。现实中应用场景很多CEO、经理等都是。spring中的Application，数据库的连接池都有使用。
二、饿汉式单例模式
饿汉式单例模式是在类加载的时候就已经初始化实例来了，可能是饿怕了，哈哈。饿汉式单例是绝对线程安全的，因为在你线程还没生出来的时候，人家已经准备好迎接了。无论怎么操做都是人家提前准备好的，也就不存在安全问题了。饿汉式单例的优缺点如下：
- 优点：没有加任何锁、执行效率比较高，用户体验会比懒汉式更好，spring的Application就是使用的该模式。
- 缺点：类加载的时候就初始化，无论使用不使用都会占有空间，会出现占着茅坑不拉屎的现象。
我们看一下饿汉式单例的代码：
public class HungrySingleton {
private static final HungrySingleton single = new HungrySingleton();
// 私有化构造器，让别人不能够创建对象
private HungrySingleton(){};
// 开放一个全局入口
public static HungrySingleton getInstance(){
return single;
}
}
饿汉式单例使用的还是比较少的。
三、懒汉式单例模式
懒汉式单例模式的特点是：被外部类调用的时候内部类才会加载，这样就会避免占着茅坑不拉屎的现象了。我们先看一个简单的例子：
public class LazySimpleSingleton {
private static LazySimpleSingleton singleton = null;
private LazySimpleSingleton() { }
public static LazySimpleSingleton getInstance() {
if (singleton == null) {
singleton = new LazySimpleSingleton();
}
return singleton;
}
}
但是，这样会出现线程安全问题。也就是又可能它不是单例的。因此，我们需要优化一下代码，使其能够在多线程环境下面安全运行。例如加上synchronized关键字，代码如下：
public class LazySimpleSingleton {
private static LazySimpleSingleton singleton = null;
private LazySimpleSingleton() { }
public synchronized static LazySimpleSingleton getInstance() {
if (singleton == null) {
singleton = new LazySimpleSingleton();
}
return singleton;
}
}
这样的话，就解决了线程安全的问题了。但是，synchronized加锁时，在线程数量比较多的情况下，CPU分配压力上升，就会导致大量的阻塞，从而导致程序性能大幅度下降。因此，我们需要一种既能兼顾线程安全又能提升程序性能的方式了。我们的双重检查锁单例模式就需要闪亮登场了。
public class LazyDoubleCheckSingleton {
private LazyDoubleCheckSingleton() {
}
private volatile static LazyDoubleCheckSingleton singleton = null;
public static LazyDoubleCheckSingleton getInstance() {
if (singleton == null) {
synchronized (LazyDoubleCheckSingleton.class){
if (singleton == null){
singleton = new LazyDoubleCheckSingleton();
}
}
}
return singleton;
}
}
加上锁，难免对程序性能会有一定的影响。那我们是否能够不添加锁却还还能够保证线程安全呢。答案是肯定的。我们可以从类初始化的角度来考虑，采用静态内部类的方式进行操作：
public class LazyInnerSingleton {
private LazyInnerSingleton() {}
// 全局暴漏接口
public static final LazyInnerSingleton getInstance(){
return LazyHolder.LAZY;
}
// 内部类，默认不加载，是有在使用LazyInnerSingleton的时候，才会先初始化
private static class LazyHolder{
private static final LazyInnerSingleton LAZY = new LazyInnerSingleton();
}
}
这种方式即可以做到不浪费内存，又做到了线程安全的问题。内部类是在外部类使用的时候初始化的，避免了提前初始化造成的内存浪费。同时，内部类又是在方法调用之前初始化的，巧妙的避免了线程安全问题。
在实际项目中，我们还会遇到一些其他的问题，我们也知道，创建对象的方式不是只有new一家，我们还可以通过反射进行创建，但是看我们以上的代码，并没有对这一块做任何限制，也就是当我们的单例碰到反射的时候，就只能任人宰割了。怎么办呢，我的对象是不能够让别人肆意蹂躏的(愤怒)。我们可以找警察叔叔啊，优化如下：
public class LazyInnerSingleton {
private LazyInnerSingleton() {
// 他如果想强行来，我们就找警察叔叔
if (LazyHolder.LAZY != null) {
throw new RuntimeException("不允许创建多个实例");
}
}
// 全局暴漏接口
public static final LazyInnerSingleton getInstance(){
return LazyHolder.LAZY;
}
// 内部类，默认不加载，是有在使用LazyInnerSingleton的时候，才会先初始化
private static class LazyHolder{
private static final LazyInnerSingleton LAZY = new LazyInnerSingleton();
}
}
还有，序列化也可以破坏单例，这个注册式单例可以帮我们解决。
四、注册式单例
注册式单例是将每一个单例登记到一个地方，使用的时候在通过标示获取。也就是把所有的单例对象先存起来。。。注册式单例有两种：枚举式和容器式。这两种单例可以很好的解决序列化破坏单例的问题
4.1 枚举式单例模式
直接上代码：
public enum EnumSingleton {
INSTANCE;
private Object data;
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public static EnumSingleton getInstance(){
return INSTANCE;
}
}
4.2 容器式单例
代码如下：
public class ContainerSingleton {
private ContainerSingleton() {
}
private static Map<String, Object> ioc = new ConcurrentHashMap<>();
public static Object getBean(String className) {
synchronized (ioc){
if (!ioc.containsKey(className)) {
Object obj = null;
try {
obj = Class.forName(className).newInstance();
}catch (Exception e){
e.printStackTrace();
}
return obj;
} else {
return ioc.get(className);
}
}
}
}
他，适用于单例实例特别多的情况下。在spring中有使用到。
