23中设计模式（1）：单例模式

定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

1.设计要点

• 构造方法私有化。
• 有指向自己实例的静态私有引用。
• 有对外提供自身实例的静态公有方法。

2.实现方式

根据实例化对象时机的不同分为三种：

一种是饿汉式单例，一种是懒汉式单例，还有一种是枚举实现，它是饿汉式单例的一种特殊情况。

• 饿汉式单例，在单例类被加载时候，就实例化一个对象交给自己的引用。

  /**
   * 饿汉式单例（可以使用）
   *
   * @author suvue
   * @date 2020/1/9
   */
  public class HungryStyle {
      private static HungryStyle instance = new HungryStyle();
  
      private HungryStyle() {
      }
  
      public static HungryStyle getInstance() {
          return instance;
      }
  }
  

• 懒汉式单例，是指在调用取得实例方法的时候才会实例化对象。其实懒汉模式的单例创建有很多种，这里列举推荐使用的中l两种方式。

  双重检索方式

  结合了其余方式做了改进，其他方式的缺点如将同步锁加到getInstance()方法上，会导致速率很慢；而不进行双重检索（也就是不进行第二次校验），就会有线程安全问题，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

  /**
   * 懒汉式单例（双重检索，推荐使用）
   *
   * @author suvue
   * @date 2020/1/9
   */
  public class DoubleCheckStyle {
      //volatile的使用是为了防止指令重排。
      private static volatile DoubleCheckStyle instance = null;
  
      private DoubleCheckStyle() {
      }
  
      public static DoubleCheckStyle getInstance() {
          if (instance == null) {
              synchronized (DoubleCheckStyle.class) {
                  if (instance == null) {
                      //new对象的过程可拆解为三个过程：
                      //1.为新对象分配内存空间
                      //2.将变量引用的指针指向内存地址。
                      //3.实例化对象的一系列过程
                      //假如一个线程执行了1、2，还没来得及执行3，这时为它分配的执行时间
                      //用完了，另一个线程进来，此时因为上一个线程执行了2，那么它会以为已经
                      //实例化好对象了，就开心的拿着这个单例对象执行操作去了，实际上只分配了
                      //内存空间和引用，而没有进行实例化，所以这个线程用的时候就会抛异常。
                      instance = new DoubleCheckStyle();
                  }
              }
          }
          return instance;
      }
  
  }
  

  静态内部类方式

  这种方式和饿汉式单例一样，都是采用类加载机制，但是不同的是，饿汉式在类加载时进行初始化，静态内部类方式在调用getInstance方法时才会实例化。

  优点：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（类的静态属性只会在第一次加载类的时候初始化，所以JVM帮助我们保证了线程的安全性）。

  缺点：需要两个类去完成这一实现，虽然不会创建静态内部类的对象，但是其 Class 对象还是会被创建，而且是属于永久带的对象。因此创建好的单例，一旦在后期被销毁，不能重新创建。

  /**
   * 懒汉式单例(通过静态内部类的方式实现，推荐使用)
   *
   * @author suvue
   * @date 2020/1/9
   */
  public class StaticInnerStyle {
      private StaticInnerStyle() {
  
      }
  
      private static class InnerInstance {
          private final static StaticInnerStyle INSTANCE = new StaticInnerStyle();
      }
  
      public static StaticInnerStyle getInstance() {
          return InnerInstance.INSTANCE;
      }
  }
  

• 枚举式单例借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

  package cn.suvue.discipline.practice.designpattern.singleton;
  
  /**
   * 枚举方式实现的单例
   *
   * @author suvue
   * @date 2020/1/9
   */
  public class EnumStyle {
      private EnumStyle() {
      }
  
      private enum Singleton {
          /**
           * 单例
           */
          INSTANCE;
          private final EnumStyle instance;
  
          Singleton() {
              this.instance = new EnumStyle();
          }
  
          private EnumStyle getInstance() {
              return instance;
          }
      }
  
      public static EnumStyle getInstance() {
          return Singleton.INSTANCE.getInstance();
      }
  }
  
  

3.优点

• 在内存中只有一个对象，节省内存空间。
• 避免频繁的创建销毁对象，可以提高性能。

4.使用注意事项

• 只能使用单例类提供的方法得到单例对象，不要使用反射，否则将会实例化一个新对象。我们的代码在反射面前就是裸奔的，它是一种非常规操作。

• 构造方法时私有的，因此单例类不可被继承。

• 多线程使用单例使用共享资源时，注意线程安全问题。

• 防止反射对单例造成破坏的方法，因为反射是基于构造方法拿到的实例，所以我们可以这么改一下：

  private StaticInnerStyle() {
          if (getInstance()!=null){
              throw new RuntimeException("调用失败");
          }
      }
  

5.单例模式在spring框架中应用

spring中使用的单例模式的懒加载，但是使用的是单例注册表实现的，先来看一个小例子。

package cn.suvue.discipline.practice.designpattern.singleton;


import java.util.concurrent.ConcurrentHashMap;
/**
 * 注册表实现的单例
 *
 * @author suvue
 * @date 2020/1/9
 */
public class RegisterStyle {
    private static ConcurrentHashMap<String, Object> register = new ConcurrentHashMap<String, Object>(32);

    static {
        RegisterStyle res = new RegisterStyle();
        register.put(res.getClass().getName(), res);
    }

    private RegisterStyle() {
    }

    public static RegisterStyle getInstance(String name) {
        if (name == null) {
            name = "cn.suvue.discipline.practice.designpattern.singleton.RegisterStyle";
        }
        if (register.get(name) == null) {
            try {
                register.put(name, Class.forName(name).newInstance());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return (RegisterStyle) register.get(name);
    }
}

上述的代码很简单，实现思路大同小异，唯一的不同是用到了ConcurrentHashMap。下面我们来看一下Spring中的应用。最经典的就是BeanFactory的获取bean的时候。

@SuppressWarnings("unchecked")
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

        //校验bean名是否有非法字符
		final String beanName = transformedBeanName(name);
		Object bean;

		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			//...
            //获取bean的实例
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			//...

			try {
                //获取并检查bean的定义
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				//...

				// 创建bean的实例 类定义是单例的情况.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
                            //出错了要销毁bean
							destroySingleton(beanName);
							throw ex;
						}
					});
                    //获取bean的实例
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

                //多例情况 这里不多分析
				else if (mbd.isPrototype()) {
				     //...
				}

				//作用域相关代码，这里不看它
                //...
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		if (requiredType != null && !requiredType.isInstance(bean)) {
			//校验bean的类型是否与实际的相匹配
            //...
		}
		return (T) bean;
	}

上面是我简化过的代码，我们着重看下是单例情况，也就是getSingleton方法的具体实现。

/** 单例对象的缓存容器，key是bean的名称，value是bean的实例 */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);


public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				//...
				boolean newSingleton = false;
				//...
				try {
                    //这里实际上创建一个新的对象
                    //因为这里的singletonFactory
                    //实际上传进来的是createBean(beanName, mbd, args)
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
				    //创建实例因为容器中已经存在了，就抛出异常，然后到容器中直接取单例对象
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				//...
				if (newSingleton) {
                    //如果是新的实例对象，那么就添加到容器中
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

下面我们看看spring是怎么往容器中放单例对象的。

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
            //直接在同步代码块 执行put操作
            //上段代码的getSingleton方法 用了一个synchronized
            //本段代码中addSingleton方法 也用了一个synchronized
            //并且锁的对象都是singletonObjects
			this.singletonObjects.put(beanName, singletonObject);
            //下面的代码可以不用看，重要的是上面这行
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

6.单例对象究竟会不被GC垃圾回收机制回收呢？

答案是不会。

实践出真知，我们可以通过测试代码来进行实验的。

class Singleton {
    //饿汉式单例，bytes数组模拟该单例对象占了100M堆内存
    private static byte[] bytes = new byte[1024 * 1024 * 100];

    private Singleton() {
    }

    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }

}

class OtherObject {
    //模拟其它一些对象，假设都占用了虚拟机5M堆内存
    private byte[] bytes = new byte[1024 * 1024 * 5];
}


public class SingletonTest {
    public static void main(String[] args) {
        //获取单例对象
        Singleton instance = Singleton.getInstance();
        //死循环创建对象，然后观察虚拟机中堆内存大小的变化
        while (true) {
            new OtherObject();
        }

    }
}

我们采用jdk自带的可视化工具jvisualvm.exe，可以在jdk根目录下/bin/ 下找到它。

下图中我们可以直观的看到，GC每次回收后都剩余了100MB的堆内存。而我们模拟的单例对象刚好占用了100MB的内存，说明在正常情况下，Java中GC垃圾回收机制是不会回收单例对象的，除非人为的破坏了对象与引用之间的联接。

以上是我的一些粗鄙观点，希望看到本博文的大神能纠正其中的错误！万分感谢哦，以后我对单例有了新的认知了，会不断来补充更新的，也希望大神们多提提意见！