单例模式

单例模式：一个类只能创建一个对象的设计模式

单例模式代码实现

懒汉模式

/*
 * 要想让一个类只能构建一个对象，则不能让他随便进行new，因此构造方法是私有的
 * 懒汉模式（如果单例初始值为null，则构建单例对象）
 */
public class Singleton {

    //私有构造函数
    private Singleton()
    {

    }

    //单例对象
    private static Singleton instance = null;

    //静态工厂方法
    public static Singleton getInstance()
    {
        if(instance == null)
        {
            instance = new Singleton();
        }   
        return instance;
    }
}

以上创建单例模式的方法是非线程安全的

假设Singleton类刚刚被初始化，instance对象还是空，这时候有两个线程A和B同时访问getInstance()方法。因为instance为空，所以两个线程都通过了条件判断，开始执行 new new Singleton()操作，致使instance被创建了两次。

饿汉模式

/*
 * 饿汉模式：单例对象一开始就被new Singleton1()主动创建，不再进行判空操作
 */
public class Singleton1 {
    //私有构造函数
    private Singleton1()
    {

    }

    //单例对象
    private static Singleton1 instance = new Singleton1();

    //静态工厂方法
    public static Singleton1 getInstance()
    {
        return instance;
    }
}

线程安全的单例模式

为了实现线程安全，在懒汉模式上我们进行改进，即防止new Singleton（）被执行多次，这里可以使用Synchronized来进行同步。

public class Singleton2 {
    //私有构造函数
    private Singleton2()
    {

    }

    //单例对象
    private static Singleton2 instance = null;

    //静态工厂方法
    public static Singleton2 getInstance()
    {
        //双重检测
        if(instance == null)
        {
            //使用同步锁，锁住整个类
            synchronized (Singleton2.class) { 
                if(instance==null)
                {
                    instance = new Singleton2();
                }
            }
        }

        return instance;
    }
}

上面这种写法事实还是存在一定问题的
JVM编译器会对指令进行重排

instance=new Singleton()
其实在执行时分三步：
1、首先分配对象的内存空间
2、初始化对象
3、设置instance指向刚分配的内存地址

但是并不是一定按照1，2，3的顺序进行执行，CPU和JVM可能会对指令进行重排。
假设按照1，3，2的顺序进行执行。则线程A执行完1，3后，instance对象并未进行初始化，但是它已经不再指向null，此时如果线程B执行if判断，则结果是false，直接return instance，这里反悔了一个没有初始化完成的instance对象。

为了避免这种情况的发送，即避免指令重排，我们可以在instance对象前加上修饰符volatile
volatile阻止了变量访问前后的指令重拍，保证了指令执行顺序。
volatile在多处理器开发中保证了共享变量的可见性。
由于现在的操作系统，都有缓存机制。当一个线程执行时，它会维护一个私有的堆栈，与公共堆栈中的数据并不是时刻保持一致的。正是由于缓冲区和内存区数据的不一致性，导致程序执行结果出现差别。volatile通过内存屏障，强制从公共堆栈中取得变量的值。
内存屏障指令在多核处理器下会引发两件事：
将当前处理器缓存行的数据写会到系统内存
这个写会内存的操作会使其他CPU里缓存了该内存地址的数据无效。

public class Singleton3 {
    //私有构造函数
    private Singleton2()
    {

    }

    //单例对象
    private volatile static Singleton2 instance = null;

    //静态工厂方法
    public static Singleton2 getInstance()
    {
        //双重检测
        if(instance == null)
        {
            //使用同步锁，锁住整个类
            synchronized (Singleton2.class) { 
                if(instance==null)
                {
                    instance = new Singleton2();
                }
            }

        }

        return instance;
    }
}

静态内部类实现

public class Singleton3 {
    private Singleton3(){}
    private static class LazyHolder{
        private static final Singleton3 INSTANCE = new Singleton3();
    }

    public static Singleton3 getInstance()
    {
        return LazyHolder.INSTANCE;
    }
}

从外部是无法访问静态内部类LazyHolder的 ，只有调用Singleton.getInstance（）方法，才能得到单例对象INSTANCE。这是种懒加载的方式，只有执行Singleton.getInstance（），INSTANCE对象才被初始化。

以上的方式都有一个问题，就是无法防止利用反射来重新构建对象
先来看一下如何利用反射打破单例的约束

public class BreakSingletonByReflect {
    public static void main(String[] args) throws Exception{
        //先获取单例类的构造器
        Constructor<Singleton3> con = Singleton3.class.getDeclaredConstructor();
        //设置改构造器为可访问
        con.setAccessible(true);
        //构造两个不同的对象
        Singleton3 singleton1 = con.newInstance();
        Singleton3 singleton2 = con.newInstance();
        System.out.println("两个对象是否相等"+singleton1.equals(singleton2));
    }
}

输出结果是：两个对象是否相等false
如何防止反射来重建单例对象？使用枚举的方式

用枚举实现

public enum SingletonEnum{
    INSTANCE;
    private SingletonEnum()
    {
        ....
        ....
        ....
    }
}

参考http://mp.weixin.qq.com/s/2UYXNzgTCEZdEfuGIbcczA