单例模式

1. 定义：确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例

2. 实现单例的关键点：
   构造函数不对外开放，一般为private
   通过静态方法或者枚举返回单例类对象
   确保单例类的对象有且只有一个，尤其在多线程环境下
   确保单例在反序列化时不会重新构建函数

3. 实现方式
   饿汉模式

private static SignalTask mSignalTask = new SignalTask();
    private SignalTask(){}
    public static SignalTask getInstance(){
        return mSignalTask;
    }

特点：线程安全，但是无论需不需要在加载时就创建了对象，浪费资源

懒汉模式

private static SignalTask mSignalTask;
    public static SignalTask getInstance(){
        if(mSignalTask == null){
            mSignalTask = new SignalTask();
        }
        return mSignalTask;
    }

特点：线程不安全；在一定程度上节约了资源，但在第一次加载时要实例化，会反映稍慢

要保证线程安全需要加synchronized关键字
http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html

private static SignalTask mSignalTask;
    public static synchronized SignalTask getInstance(){
        if(mSignalTask == null){
            mSignalTask = new SignalTask();
        }
        return mSignalTask;
    }

但是这种写法最大的问题是在每次调用函数是都进行同步，造成不必要的同步开销，所以懒汉模式不建议使用

DCL双重检查锁

private static SignalTask mSignalTask;
    public static SignalTask getInstance(){
        if(mSignalTask == null){
            synchronized (SignalTask.class) {
                if(mSignalTask == null){
                    mSignalTask = new SignalTask();
                }
            }
        }
        return mSignalTask;
    }

【双重检查的目的：
 考虑这样一种情况，就是有两个线程同时到达，即同时调用 GetInstance（），

此时由于 singleton == null ，所以很明显，两个线程都可以通过第一重的 singleton == null ，

进入第一重 if 语句后，由于存在锁机制，所以会有一个线程进入 lock 语句并进入第二重 singleton == null ，

而另外的一个线程则会在 lock 语句的外面等待。

而当第一个线程执行完 new Singleton（）语句后，便会退出锁定区域，此时，第二个线程便可以进入 lock 语句块，

此时，如果没有第二重 singleton == null 的话，那么第二个线程还是可以调用 new Singleton（）语句，

这样第二个线程也会创建一个 Singleton 实例，这样也还是违背了单例模式的初衷的，

所以这里必须要使用双重检查锁定。

细心的朋友一定会发现，如果我去掉第一重 singleton == null ，程序还是可以在多线程下完好的运行的，

考虑在没有第一重 singleton == null 的情况下，

当有两个线程同时到达，此时，由于 lock 机制的存在，第一个线程会进入 lock 语句块，并且可以顺利执行 new Singleton（），

当第一个线程退出 lock 语句块时， singleton 这个静态变量已不为 null 了，所以当第二个线程进入 lock 时，

还是会被第二重 singleton == null 挡在外面，而无法执行 new Singleton（），

所以在没有第一重 singleton == null 的情况下，也是可以实现单例模式的？那么为什么需要第一重 singleton == null 呢？

这里就涉及一个性能问题了，因为对于单例模式的话，new Singleton（）只需要执行一次就 OK 了，

而如果没有第一重 singleton == null 的话，每一次有线程进入 GetInstance（）时，均会执行锁定操作来实现线程同步，

这是非常耗费性能的，而如果我加上第一重 singleton == null 的话，

那么就只有在第一次，也就是 singleton ==null 成立时的情况下执行一次锁定以实现线程同步，

而以后的话，便只要直接返回 Singleton 实例就 OK 了而根本无需再进入 lock 语句块了，这样就可以解决由线程同步带来的性能问题了。

好，关于多线程下单例模式中的双重检查锁定的实现和目标介绍就到这里了。
http://plplum.blog.163.com/blog/static/31032400201241534840891/】
可能存在的问题：java处理器乱序执行导致初始化不完整报错
http://blog.youkuaiyun.com/turkeyzhou/article/details/6179951

为了避免错误在变量声明时加volatile关键字

private static volatile SignalTask mSignalTask;

这种模式可能会出现双重检查锁定失效
静态内部类模式

建议使用的方法

private SignalTask(){}
    public static SignalTask getInstance(){
        return SignalHolder.sInstance;
    }

    private static class SignalHolder{
        private static final SignalTask sInstance = new SignalTask();
    }

特点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗，静态内部类只有当被调用的时候才开始首次被加载
原理：类级内部类相当于其外部类的成员，只有在第一次被使用的时候才会被装载，且JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的

枚举单例

public enum SingletonEnum {
        /**
         * 1.从Java1.5开始支持;
         * 2.无偿提供序列化机制;
         * 3.绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候;
         * 4.默认枚举实例的创建是线程安全
         */

        instance;
        public void method() {
            System.out.println("SingletonEnum");
        }
    }

以上几种方式防止单例对象反序列化时再重新创建对象须加入如下方法：

使用容器实现内部类
用于管理多种类型的单例

private static Map<String , Object> objMap = new HashMap<String , Object>();

    private SignalTask(){}
    public static void registerService(String key, Object instance){
        if(!objMap.containsKey(key)){
            objMap.put(key, instance);
        }
    }

    public static Object getService(String key){
        return objMap.get(key);
    }