单列模式详解一

单列模式的应用场景

• 单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建新模式。J2EE标准中的ServletContext、ServletContextConfig 等、Spring 框架应用中的ApplictionContext、数据库的连接池等都是单例形式。

饿汉式单例模式

• 先来看单例模式的类结构图，如图

• 饿汉式单例模式在类加载的时候立即初始化，并且创建单例对象。它是绝对线程安全，在线程还没出现以前就实例化了，不可能存在线程安全问题。

  优点： 没有加任何锁、执行效率比较高，用户体验比懒汉式单例模式好。

  缺点： 类加载的时候就初始化，不管用不用都占用空间，浪费了内存。

• Spring 中Ioc 容器ApplicationContext本身就是典型的饿汉式单例模式，接下来看一段代码。

public class HungrySingleton {

    private static final HungrySingleton HUNGRY_SINGLETON = new HungrySingleton();

    private HungrySingleton(){

    }
    public static HungrySingleton getInstance(){
        return HUNGRY_SINGLETON;
    }
}

• 还有另一种写法静态代码块机制

public class HungryStaticSingleton {
    private static final HungryStaticSingleton HUNGRY_SINGLETON;

    static {
        HUNGRY_SINGLETON = new HungryStaticSingleton();
    }
    private HungryStaticSingleton(){

    }

    public static HungryStaticSingleton getInstance(){
        return HUNGRY_SINGLETON;
    }
}

• 这两种写法都非常简单，也非常好理解，饿汉式单例模式适用于单例对象比较少的情况，下面我们看性能更优的写法。

懒汉式单例模式

• 懒汉式单例模式的特点是：被外部类调用的时候内部类才会加载。下面看懒汉模式的简单实现

//懒汉式单例模式在外部需要使用的时候才进行实例化
public class LazySimpleSingleton {
    private static  LazySimpleSingleton LAZY_SIMPLE_SINGLETON = null;
    private LazySimpleSingleton(){}
    public static LazySimpleSingleton getInstance(){
        if(LAZY_SIMPLE_SINGLETON == null){
            LAZY_SIMPLE_SINGLETON = new LazySimpleSingleton();
        }
        return LAZY_SIMPLE_SINGLETON;
    }
}

• 然后我们写一个线程类

public class ExectorThread implements Runnable {
    @Override
    public void run() {
        LazySimpleSingleton lazySimpleSingleton = LazySimpleSingleton.getInstance();

        System.out.println(Thread.currentThread().getName()+":"+ lazySimpleSingleton);
    }
}

• 测试代码

public class LazySimpleSingletonTest {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new ExectorThread());
        Thread thread2 = new Thread(new ExectorThread());
        thread1.start();
        thread2.start();
    }
}

• 运行结果：

• 上面的代码一定概率出现两种不同的结果，意味着上面的单例模式存在安全隐患。那么我们怎样优化代码才能使得懒汉式单例模式线程安全呢？来看代码我们在getInstance()方法加上synchronized关键字，使这个方法变成线程同步方法。

public class LazySimpleSingleton {

    private static  LazySimpleSingleton lazy = null;

    private LazySimpleSingleton(){}
    public synchronized static LazySimpleSingleton getInstance(){
        if(lazy == null){
            lazy =  new LazySimpleSingleton();
        }
        return lazy;
    }
}

• 虽然线程安全问题解决了，但是用synchronized加锁时，在线程数量比较多的情况下，如果cpu分配压力上升，则会导致线程阻塞，性能大幅下降，我们引入一种新的方式，双重加锁

public class LazySimpleSingleton {

    private volatile static  LazySimpleSingleton lazy = null;

    private LazySimpleSingleton(){}
    public  static LazySimpleSingleton getInstance(){
        if(lazy == null){
            synchronized (LazySimpleSingleton.class){
                if(lazy == null){
                    lazy =  new LazySimpleSingleton();
                }
            }
        }
        return lazy;
    }
}

• 优化后的结果是代码块的阻塞，逻辑不复杂的情况下感知较小。但是用到synchronized 关键字总归要上锁，看下边一种写法，采用静态内部类：

//这种形式兼顾了饿汉式单例模式的内存浪费问题 和sychronized 的性能问题
public class LazyInnerClassSingleton {
    //使用LazyInnerClassSingleton的时候，默认会先初始化内部类
    //入股没使用则内部类是不加载的
    private LazyInnerClassSingleton(){}
    //static 关键字是为了使单例的空间共享，不会被重写，重载
    public static  final LazyInnerClassSingleton getInstance (){
        return LazyHolder.LAZY;
    }
    //默认不加载
    private static class LazyHolder{
        private static  final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }

}

• 这种方式兼顾了饿汉式单例模式的内存浪费问题和synchronized的性能问题，内部类一定要在方法调用之前初始化，巧妙的避免了线程安全问题。
• 下期：单例模式详解二 以及更优的单例模式。谢谢。