单例设计模式

单例设计模式是用的最多的设计模式，也是最简单的一中设计模式。下面来介绍下几种实现单例的方式，以及分析下各自的优缺点。

饿汉式

    public  class CEO {
        private static final CEO instance = new CEO();

        private CEO() {
        }

        public static CEO getInstance() {
            return instance;
        }
    }

构造函数私有，利用共有的静态函数，对外暴露获取单例对象的接口。CEO对象在声明的时候就初始化了，并且是静态的。这样就保证了对象的唯一性。

懒汉式

 public  class Singleton {
        private static Singleton instance = null;

        private Singleton() {
        }

        public static synchronized Singleton getInstance() {
            if (instance == null)
                instance = new Singleton();
            return instance;
        }
    }

与饿汉式的区别是静态对象在第一次调getInstance()时进行初始化。
synchronized确保getInstance()是个同步方法，用来确保在多线程情况下单例的唯一性。
优点：只有在使用时才被初始化，节约资源
弊端：每次调用getInstance()都需要同步，造成不必要的同步开销

Double Check Lock（DCL）实现单例

这种模式其实是对懒汉式的优化，将锁放到内部，当第一次初始化单例的时候才同步：

 public  class Singleton {
        private static Singleton instance = null;

        private Singleton() {
        }

        public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    if (instance == null)
                        instance = new Singleton();
                }
            }
            return instance;
        }
    }

上面进行2次判空：
第一次是为了避免不必要的同步
第二次是为了在null的情况下创建实例
为什么要进行第二次判空呢？
我们看下instance = new Singleton()这步会做什么：
1、给Singleton的实例分配内存；
2、调用Singleton()的构造函数，初始化成员字段；
3、将instance对象指向分配的内存空间（这样instance就不是null了）
但是JDK1.5之前并不能保证第二步和第三步的顺序，如果先走的3，那么此时如果有另外个线程getInstance()那么它就可以直接获取单例对象，当他使用的时候就会出错。
JDK1.5之后只需要将instance第一为private volatile static Singleton instance = null;这样就行。添加关键字volatile保证instance每次都是从主内存中读取。

静态内部类单例模式

DCL虽然了资源消耗、多余同步、线程安全等问题，但是在某些并发情况下会失效，因此并步推荐使用DCL。
下面这种通过静态内部类实现单例的方法是推荐使用的：

   public  class Singleton {


        private Singleton() {
        }

        /**
         * 静态内部类
         */
        private static class SingletonHolder {
            private static final Singleton instance = new Singleton();
        }

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

1、instance只有在调getInstance()的时候才初始化
2、通过静态内部类不仅能确保线程安全，也能保证单例的唯一性

枚举单例

其实考虑到唯一性和线程安全性的时候我就应该想到枚举，下面我们通过枚举来实现单例

public enum Singleton {
        SINGLETON;
    }

先不说性能，至少这是实现单例最简单的方法。
枚举的好处是默认枚举实例的创建是线程安全的，并且任何情况下它都是一个单例。
之前几种方法都会存在一个问题，就是在反序列化时，可能创建一个新的实例

总结

不管哪种形式实现单例，核心原理就是将构造函数私有化，并通过静态方法获取唯一的实例。在获取这个实例的过程中要保证线程安全、唯一性等问题