单例模式详解

单例模式的应用场景
单例模式（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 性能问题。内部类一定是要在方
法调用之前初始化，巧妙地避免了线程安全问题。

 

最后反射和序列化都会破坏线程，关于这一部分原理以及避免方法我会另外再写一篇文章介绍