1 单例模式

单例模式：确保某一个类只有一个实例，自行实例化并向整个系统提供这个实例。

使用场景

确保某个类只有一个对象的场景，避免产生多个对象消耗资源，或者某个对象应该有且只有一个的场景。

特点

1.构造函数不对外开放，一般为private

2.通过静态方法返回单例类的对象

3.确保对象只有一个，尤其是在多线程的情况下

4.确保单例类对象在反序列化时不会重新创建对象

写单例

一：饿汉模式

    public class Singleton {
        private static final Singleton singleton = new Singleton();
        private Singleton(){
        }
        public static Singleton getInstance(){
            return singleton;
        }
        //  do.....
    }

二：懒汉模式

    public class SingletonV2 {
        private static SingletonV2 singletonV2 = null;
        private SingletonV2(){
        }
        public static synchronized SingletonV2 getInstance(){
            if(singletonV2 != null){
                singletonV2 = new SingletonV2();
            }
            return singletonV2;
        }
        // do....
    }

优点：只有在使用时才会被实例化
缺点：每次使用都要进行同步，即使单例已经存在，造成不必要的同步开销

三：DCL实现单例（双锁）

    public class SingletonV3 {
        private static SingletonV3 singletonV3 = null;
        private SingletonV3(){
        }
        public static SingletonV3 getInstance(){
            if(singletonV3 == null){
                synchronized (SingletonV3.class){
                    if(singletonV3 == null){
                        singletonV3 = new SingletonV3();
                    }
                }
            }
            return singletonV3;
        }
        // do ....
    }

DCL失效问题：

singletonV3 = new SingletonV3(); 一句代码，却不是原子性操作，会被编译成多条汇编指令，但大致作了三件事：

1.给SingletonV3的实例分配内存；

2.调用SingletonV3的构造函数，初始化字段；

3.将singletonV3指向分配的内存空间（这时singletonV3 不为 null）

JDK1.5之前java编译器允许处理器乱序执行，上面2，3的执行顺序是无法保证的，所以执行顺序可能是1-2-3，也可能是1-3-2，如果是后者，则有可能出现3执行完毕，2还未执行，此时singletonV3已经不为null，但另一个线程取走singletonV3，使用就会出错。

jdk1.5之后，使用volatile，修改为private volatile static SingletonV3 singletonV3 = null;就可以保证singletonV3保证每次都是从主内存中读取。

能够在绝大多数情况保证单例对象的唯一性，除非在并发场景比较复杂或JDK低于6的版本下使用。

四：静态内部类实现

    public class SingletonV4 {
        private SingletonV4(){
        }
        public static SingletonV4 getInstance(){
            return SingletonHolder.singletonV4;
        }
        private static class SingletonHolder{
            private static final SingletonV4 singletonV4 = new SingletonV4();
        }
    }

第一次加载SingletonV4时并不会初始化singletonV4，只有第一次调用getInstance()才会导致加载SingletonHolder类，线程安全，而且保证对象的唯一性，切延迟实例化，推荐的单例实现方式。

五：枚举实现单例

public enum SIngletonEnum {
    Instance;
    // do something
    private int num = 10;
    public int doSomething(){
        return num;
    }
    //
}

枚举单例的最大特点就是简单，枚举不仅能够有字段，还能够有方法，枚举单例是线程安全的。

反序列化

序列化操作提供了一个很特别的钩子（hook）-类中具有一个私有的被实例化的方法readresolve(),这个方法可以确保类的开发人员在序列化将会返回怎样的object上具有发言权。

     private Object readResolve() throws ObjectStreamException {
         return getInstance();
     }