在《Spring框架 之 Spring理论基础》(https://www.jianshu.com/p/5673d0c99d1c)中我们说到实际开发工作中我们经常使用单例模式来设计对象的生命周期，本篇将就单例模式的实现做出详细讲解。
常用的单例模式大体上分为懒汉式与饿汉式，以及Spring中使用的注册表式三种。
一、懒汉式
懒汉式单利模式下，工具类加载时并不会立刻创建实例，只有需要用到该类的实例时，才会为该类创建实例。下面给出常用的四种懒汉式单例模式的实现。
1.简单懒汉
<pre class="java" style="box-sizing: border-box; margin: 0px 0px 24px; padding: 0px 16px; overflow-x: auto; background-color: rgb(240, 240, 240); font-family: Consolas, Inconsolata, Courier, monospace; font-size: 12px; line-height: 20px; color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">public class SingletonTest {
private static SingletonTest singletonTest;
public static SingletonTest getInstance() {
if(singletonTest==null) {
singletonTest=new SingletonTest();
}
return singletonTest;
}
} </pre>
在实际开发中，为了便于管理，我们常将获取实例的方法统一封装进工具类中，而本文为了方便查看代码，我将获取实例的方法写入本类中，读者朋友测试时可以自行编写工具类，也可以直接将本类当做工具类来理解。
懒汉式单例模式下，首次加载SingletonTest类时，并不会立即创建实例，而是只有通过调用getInstance方法，才会创建该类的实例并返回此实例，每次调用getInstance方法都只会获得同一个实例。
2.加同步锁
在简单懒汉中，如果有多个线程并发访问getInstance方法，将导致创建多个实例，并且有可能线程之间获得的并不是同一个对象，很容易对此作出测试。
我们在主线程中启动三个线程，并发访问获得SingletonTest类的实例并输出，运行结果有可能会出现获得的实例不唯一的情况（取决于计算机的当前状态，多试几次一定会出现线程安全问题）：
20180216104237117.jpg
所以我们引入同步锁来处理线程安全问题：
<pre class="java" style="box-sizing: border-box; margin: 0px 0px 24px; padding: 0px 16px; overflow-x: auto; background-color: rgb(240, 240, 240); font-family: Consolas, Inconsolata, Courier, monospace; font-size: 12px; line-height: 20px; color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">package practice.CSDNTest.singleton;
public class SingletonTest {
private static SingletonTest singletonTest;
public static synchronized SingletonTest getInstance() {
if(singletonTest==null) {
singletonTest=new SingletonTest();
}
return singletonTest;
}
} </pre>
在方法体上加锁后，使得每次只有一个线程能够执行整个方法，解决了线程安全问题。
3.双重锁机制
上面简单的加同步锁的方式，存在很大的性能问题。实际上，即使有大量的线程并发访问getInstance方法获得实例，也只有优先抢占到CPU资源的前几个线程有可能发生线程安全问题，之后再执行方法的线程都是只读操作，将不会再有并发问题。然而，如果我们将整个方法都加锁处理，将导致无论有没有可能发生并发问题，所有线程都必须在方法外等候，逐一执行方法，这将导致大量的性能浪费。
所以我们引入双重检查锁机制来过滤线程，只对前几个线程进行同步处理。
<pre class="java" style="box-sizing: border-box; margin: 0px 0px 24px; padding: 0px 16px; overflow-x: auto; background-color: rgb(240, 240, 240); font-family: Consolas, Inconsolata, Courier, monospace; font-size: 12px; line-height: 20px; color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">package practice.CSDNTest.singleton;
public class SingletonTest {
private static volatile SingletonTest singletonTest;
public static SingletonTest getInstance() {
if(singletonTest==null) {
synchronized(singletonTest) {
if(singletonTest==null) {
singletonTest=new SingletonTest();
}
}
}
return singletonTest;
}
} </pre>
这里需要注意的是，成员变量singletonTest需要使用volatile关键字修饰（volatile关键字可保证变量值修改的可见性），否则双重检查锁机制可能无法正常运行。
以上三种懒汉式单例模式各有区别，第一种最简单，但不能保证多线程状态下的安全性，第二种考虑到了多线程安全性问题，但性能大打折扣，第三种方式采用细分锁的思想，即保证了多线程安全性又保证了性能。接下来我们看一种巧妙的实现方式。
4.静态内部类代理创建实例
<pre class="java" style="box-sizing: border-box; margin: 0px 0px 24px; padding: 0px 16px; overflow-x: auto; background-color: rgb(240, 240, 240); font-family: Consolas, Inconsolata, Courier, monospace; font-size: 12px; line-height: 20px; color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">package practice.CSDNTest.singleton;
public class SingletonTest {
static class SingletonTestInner{
private static final SingletonTest SINGLETON_TEST=new SingletonTest();
}
public static SingletonTest getInstance() {
return SingletonTestInner.SINGLETON_TEST;
}
} </pre>
这种方式巧妙的利用了JAVA语言内部类加载的特性：外部类加载时，不会立刻加载其内部类，而是会像普通类一样，只有当内部类被访问时才会被加载。于是以上代码便也可以实现懒汉式的单利模式，并且因为JVM中所有类都只会被加载一次，所以不需要做任何同步处理就是多线程安全的。
二、饿汉式
相较于懒汉式，饿汉式单例模式会在工具类加载时立即为指定的类创建实例存入堆中，当需要获取实例时，直接将已经创建好的实例返回给调用方。下面给出常用饿汉式的实现方式。
<pre class="java" style="box-sizing: border-box; margin: 0px 0px 24px; padding: 0px 16px; overflow-x: auto; background-color: rgb(240, 240, 240); font-family: Consolas, Inconsolata, Courier, monospace; font-size: 12px; line-height: 20px; color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">package practice.CSDNTest.singleton;
public class SingletonTest {
private static SingletonTest singletonTest=new SingletonTest();
public static SingletonTest getInstance() {
return singletonTest;
}
} </pre>
以上代码在加载SingletonTest（或工具类）时就会为成员变量singletonTest完成初始化并赋初值（归因于JVM加载类的机制），调用getInstance方法时会将已经创建的实例返回给调用方，这种方式天生就是线程安全的。
比较懒汉式单例模式与饿汉式单例模式，可以发现两者有不同的优缺点，两者各有自己适用的场景：懒汉式，延迟创建实例，适用于创建的实例对象很大，并且前期不使用，对首次访问结果返回速度要求不高，对启动速度要求高的情况；而饿汉式，提前创建实例，会占用内存，所以适用于内存状态宽裕，对启动速度要求不高的情况，并且饿汉式实例的首次访问也可迅速返回结果。
三、注册表式
除了饿汉式和懒汉式之外，我们还必须要说一下Spring容器中使用的注册表式，简单来说，就是使用同一个工具类，管理多个不同类的实例创建，每次只需在工具类中注册该类，即可获得该类的实例。注册表式也有多种实现方式，这里我们只讲解Spring容器中注册表模式的简单实现。
我们先来测试一种简单的实现方式：
<pre class="java" style="box-sizing: border-box; margin: 0px 0px 24px; padding: 0px 16px; overflow-x: auto; background-color: rgb(240, 240, 240); font-family: Consolas, Inconsolata, Courier, monospace; font-size: 12px; line-height: 20px; color: rgb(0, 0, 0); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px;">package practice.CSDNTest.singleton;
import java.util.HashMap;
import java.util.Map;
public class SingletonTestUtil {
private static SingletonTest01 singletonTest01=new SingletonTest01();
private static SingletonTest02 singletonTest02=new SingletonTest02();
private static SingletonTest03 singletonTest03=new SingletonTest03();
private static Map<String , Object> map=new HashMap<String, Object>();
static {
map.put("singletonTest01", singletonTest01);
map.put("singletonTest02", singletonTest02);
map.put("singletonTest03", singletonTest03);
}
public static <T>T getInstance(String id,Class<T> cls){
return (T)map.get(id);
}
} </pre>
这种方式是基于饿汉式的扩展（读者朋友也可以自行根据懒汉式完成注册表模式），工具类加载时为所有已经注册的类创建实例，并将实例存入集合中，调用方调用getInstance方法即可获得对应类的实例。
对于以上六种单例模式的实现，各有其最合适的使用方式，同样也可以交叉使用。另外，单例模式还有其他很多种实现方式，这里我们不一一列出，感兴趣的朋友可以自行研究。
网友评论