浅谈单例模式之懒汉式与饿汉式

java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍两种：懒汉式单例和饿汉式单例。

单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头。

其实我们在实现单例模式的时候只需要记住三点，单例模式就能轻松的写出来

1、私有的构造函数

2、私有静态单例变量

3、公有静态getInstance方法

下面来看看具体的实现：

一、饿汉式单例

/*
	饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。
*/
public class Hungry {
    //饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。
    private static final Hungry hungry = new Hungry();

    private Hungry() {

    }

    public static Hungry getInstance() {
        return hungry;
    }
}

二、懒汉式单例

1.双重检验锁

public class lazyMan {
    private volatile static lazyMan lazyMan;

    private lazyMan(){

    }

    public static lazyMan getInstance(){
        //第一重检验，目的是为了提高效率：当对象已经被实例化之后，线程就不需要再进行竞争锁了，直接返回lazyMan对象实例就可以。
        if (lazyMan==null){
            synchronized(lazyMan.class){
				//第二重检验
                if (lazyMan==null){
                    lazyMan=new lazyMan();
                }
            }
        }
        return lazyMan;
    }
}

/*
	第二重检验锁是为了保证线程同步，假若线程A通过了第一次判断，进入了同步代码块，但是还未执行，线程B就进来了（线程B获得CPU时间片），线程B也通过了第一次判断（线程A并未创建实例，所以B通过了第一次判断），准备进入同步代码块，假若这个时候不判断，就会存在这种情况：线程B创建了实例，此时恰好A也获得执行时间片，如果不加以判断，那么线程A也会创建一个实例，就会造成多实例的情况。
*/

在双重检验锁实现单例模式中还有比较重要的一点就是声明变量时必须要用volatile修饰，原因如下：

1.1 volatile关键字的作用

1. 可见性
2. 不保证原子性
3. 禁止指令重排

指令重排：你写的程序，计算机并不是按照你写的那样去执行的。
源代码-->编译器优化的重排--> 指令并行也可能会重排--> 内存系统也会重排---> 执行

比如：

int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4

我们所期望的：1234 但是可能执行的时候回变成 2134 1324

1.2 必须用volatile修饰的原因

在这里用volatile修饰的原因就是为了禁止指令重排，因为对象的创建并非一步完成，而是需要分为3个步骤执行的。

1. 分配内存空间
2、执行构造方法，初始化对象
3、把这个对象指向这个空间

我们期望的步骤是 1-> 2 ->3
但是经过指令重排后可能会变成： 1-> 3 -> 2
这在单线程情况下是没有问题的，但是在多线程情况下可能会导致一个线程得到了一个空对象。

比如： 线程A正常创建一个实例，执行了1-3，此时线程B调用getInstance()后发现instance不为空，因此会直接返回instance，但此时			instance并未被初始化，所以需要用volatile关键字修饰。

2. 静态内部类

public class Singleton{

    private Singleton(){}

    public static Singleton getInstance(){
        return InnerClass.instance;
    }

    private static class InnerClass{
        public static Singleton instance = new Singleton();
    }
}

静态内部类实现单例模式其实是利用了类加载机制来保证初始化instance时只有一个线程，因为静态变量在类加载的过程中就被JVM分配了内存空间，不需要再进行赋值。