单例模式详解
单例模式的应用场景
单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并
提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛。
例如， 国家主席、公司CEO 、部门经理等。在J2EE 标准中， ServletContext 、
ServletContextConfig 等；在Spring 框架应用中ApplicationContext；数据库的连接
池也都是单例形式。
饿汉式单例
先来看单例模式的类结构图：
饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线
程还没出现以前就是实例化了，不可能存在访问安全问题。
优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。
缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存。
Spring 中IOC 容器ApplicationContext 本身就是典型的饿汉式单例。接下来看一段代
码：
public class HungrySingleton {
//先静态、后动态
//先属性、后方法
//先上后下
private static final HungrySingleton hungrySingleton = new HungrySingleton();
private HungrySingleton(){}
public static HungrySingleton getInstance(){
return hungrySingleton;
}
还有另外一种写法，利用静态代码块的机制：
//饿汉式静态块单例
public class HungryStaticSingleton {
private static final HungryStaticSingleton hungrySingleton;
static {
hungrySingleton = new HungryStaticSingleton();
}
private HungryStaticSingleton(){}
public static HungryStaticSingleton getInstance(){
return hungrySingleton;
}}
这两种写法都非常的简单，也非常好理解，饿汉式适用在单例对象较少的情况。下面我
们来看性能更优的写法。
懒汉式单例
懒汉式单例的特点是：被外部类调用的时候内部类才会加载，下面看懒汉式单例的简单
实现LazySimpleSingleton：
//懒汉式单例
//在外部需要使用的时候才进行实例化
public class LazySimpleSingleton {
private LazySimpleSingleton(){}
//静态块，公共内存区域
private static LazySimpleSingleton lazy = null;
public static LazySimpleSingleton getInstance(){
if(lazy == null){
lazy = new LazySimpleSingleton();
}
return lazy;}}
懒汉式单例存在线程安全问题：
写一个线程类ExectorThread 类：
public class ExectorThread implements Runnable{
@Override
public void run() {
LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
System.out.println(Thread.currentThread().getName() + ":" + singleton);
}}
客户端测试代码：
public class LazySimpleSingletonTest {
public static void main(String[] args) {
Thread t1 = new Thread(new ExectorThread());
Thread t2 = new Thread(new ExectorThread());
t1.start();
t2.start();
System.out.println("End");
}}
运行结果：
那么，我们如何来
优化代码，使得懒汉式单例在线程环境下安全呢？来看下面的代码，给getInstance()加
上synchronized 关键字，是这个方法变成线程同步方法：
public class LazySimpleSingleton {
private LazySimpleSingleton(){}
//静态块，公共内存区域
private static LazySimpleSingleton lazy = null;
public synchronized static LazySimpleSingleton getInstance(){
if(lazy == null){
lazy = new LazySimpleSingleton();
}
return lazy;
}
}
这时候，我们再来调试。当我们将其中一个线程执行并调用getInstance()方法时，另一
个线程在调用getInstance()方法，线程的状态由RUNNING 变成了MONITOR,出现阻
塞。直到第一个线程执行完，第二个线程才恢复RUNNING 状态继续调用getInstance()
方法。
但是，用synchronized 加锁，在线程数量比较多情况下，如果CPU 分配压力上升，会导致大批
量线程出现阻塞，从而导致程序运行性能大幅下降。那么，有没有一种更好的方式，既
兼顾线程安全又提升程序性能呢？答案是肯定的。我们来看双重检查锁的单例模式：
public class LazyDoubleCheckSingleton {
private volatile static LazyDoubleCheckSingleton lazy = null;
private LazyDoubleCheckSingleton(){}
public static LazyDoubleCheckSingleton getInstance(){
if(lazy == null){
synchronized (LazyDoubleCheckSingleton.class){
if(lazy == null){
lazy = new LazyDoubleCheckSingleton();
//1.分配内存给这个对象
//2.初始化对象
//3.设置lazy 指向刚分配的内存地址
}
}
}
return lazy;
}
}
当第一个线程调用getInstance()方法时，第二个线程也可以调用getInstance()。当第一
个线程执行到synchronized 时会上锁，第二个线程就会变成MONITOR 状态，出现阻
塞。此时，阻塞并不是基于整个LazySimpleSingleton 类的阻塞，而是在getInstance()
方法内部阻塞，只要逻辑不是太复杂，对于调用者而言感知不到。
但是，用到synchronized 关键字，总归是要上锁，对程序性能还是存在一定影响的。难
道就真的没有更好的方案吗？当然是有的。我们可以从类初始化角度来考虑，看下面的
代码，采用静态内部类的方式：
//这种形式兼顾饿汉式的内存浪费，也兼顾synchronized 性能问题
//完美地屏蔽了这两个缺点
public class LazyInnerClassSingleton {
//默认使用LazyInnerClassGeneral 的时候，会先初始化内部类
//如果没使用的话，内部类是不加载的
private LazyInnerClassSingleton(){}
//每一个关键字都不是多余的
//static 是为了使单例的空间共享
//保证这个方法不会被重写，重载
public static final LazyInnerClassSingleton getInstance(){
//在返回结果以前，一定会先加载内部类
return LazyHolder.LAZY;
}
//默认不加载
private static class LazyHolder{
private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
}
}
这种形式兼顾饿汉式的内存浪费，也兼顾synchronized 性能问题。内部类一定是要在方
法调用之前初始化，巧妙地避免了线程安全问题。
最后反射和序列化都会破坏线程，关于这一部分原理以及避免方法我会另外再写一篇文章介绍