手把手教你学会单例模式（1）

什么是单例模式

单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，线程中的单例模式常用来做数据源的动态切换)

单例模式的种类与写法

重点，所有的单例模式记着把构造方法私有化！！！

饿汉式

听到名字就感觉两眼发绿，饿汉式是最简单的单例模式，在类初始化的时候直接创建一个单例对象，就是用到用不到先占着，比较浪费内存。

public class SimpleSingleton {
	//类初始化后直接new一个对象出来
    private static final SimpleSingleton INSTANCE = new SimpleSingleton();
    //私有化构造方法！！！！！！！！！！！！
    private SimpleSingleton() {}
    //获取单例对象
    public static SimpleSingleton getInstance() {
        return INSTANCE;
    }
}

懒加载模式

懒加载模式则是对饿汉式的一种优化，用到的时候才会初始化。

public class LazySimpleSingleton {
	//类初始化后直接new一个对象出来
    private static final LazySimpleSingleton INSTANCE = null;
    private LazySimpleSingleton() {}
    //获取单例对象
    public static LazySimpleSingleton getInstance() {
    	//在获取单例对象时进行对象的创建
        if (INSTANCE == null){
            INSTANCE = new LazySimpleSingleton();
        }
        return INSTANCE;
    }
}

但是上面这么写在单线程应用中当然是没有什么问题，但是在并发系统中，多线程同时调用getInstance()会导致对象会出初始化多次。我们来做下测试。

//实现runnable接口
public class ExecutorThread implements Runnable {
    public void run() {
        LazySimpleSingleton lazySimpleSingleton = LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + lazySimpleSingleton);
    }
}

public class LazyTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new ExecutorThread());
        Thread t2 = new Thread(new ExecutorThread());
        t1.start();
        t2.start();
    }
} 

输出结果：
Thread-0:com.chengfengfeng.singleton.lazy.LazySimpleSingleton@22c679df
Thread-1:com.chengfengfeng.singleton.lazy.LazySimpleSingleton@24189895

很明显生成了两个对象，当然，之前有小伙伴问我他的怎么生成的一样，是因为线程的调度可能使得两个线程中间间隔比较长，在一个线程初始化完对象，另一个线程在开始获取单例对象。
有没有办法解决这个问题呢？当然有，往下看。

public class LazySimpleSingleton {
	//类初始化后直接new一个对象出来
    private static final LazySimpleSingleton INSTANCE = null;
    private LazySimpleSingleton() {}
    //获取单例对象,用synchronized来对getInstance()加锁
    public synchronized static LazySimpleSingleton getInstance() {
    	//在获取单例对象时进行对象的创建
        if (INSTANCE == null){
            INSTANCE = new LazySimpleSingleton();
        }
        return INSTANCE;
    }
}

这种方式虽然解决了多线程并发的问题，尽管从java6开始已经对synchronized进行优化，但直接对方法进行加锁效率上仍然是问题，我们应该尽可能的缩小加锁的资源范围，这样就说一下对这种写法的优化方案。

双重检查模式

public class DoubleCheckSingleton {
	//类初始化后直接new一个对象出来
    private static final DoubleCheckSingleton INSTANCE = null;
    private DoubleCheckSingleton() {}
    //这个是双重检查模式
    public static DoubleCheckSingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DoubleCheckSingleton();
                }
            }
        }
        return INSTANCE;
    }
}

这里就不一一执行演示了，这样看起来似乎是完美了，但是这里要简单说个细节，那就是jvm做的的指令重排，详细的不再这里说，后面文章会单独介绍，所以我们在声明对象的时候增加一个关键字volatile进行修饰。

private volatile static DoubleCheckSingleton INSTANCE = null;

内部类单例模式

利用jvm的类的初始化规则，通过静态内部类来创建单例。这样就避免了使用synchronized带来的性能影响。

public class LazyInnerClassSingleton {
    //默认使用LazyInnerClassGeneral的时候，会先初始化内部类
    //如果没使用的话，内部类是不加载的
    private LazyInnerClassSingleton(){}
    //使用final修饰关键对象还是方法是为了保证这个方法不会被重写，重载
    public static final LazyInnerClassSingleton getInstance(){
        //在返回结果以前，一定会先加载内部类
        return LazyHolder.LAZY;
    }
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

有关内部类的加载顺序，后面写文章单独介绍。