二、单例模式

一、单例（单件）模式定义
通俗的解释：独一无二的对象

二、三大要素
1、某个类只能有一个实例。
2、他必须自行创建这个实例。
3、他必须自行向整个系统提供这个实例。

三、应用场景
1、比方说：线程池、缓存、对话框、处理偏好设置和注册表的对象、充当打印机、显卡等设备的驱动程序的对象事实上，这类对象只能有一个实例，若制造出多个实例，就会导致许多问题产生，如资源使用过量或者是不一致的结果等等。
2、资源共享的情况下，避免由于资源操作时导致的性能或损耗等，如上述中的日志对象。
3、控制资源的情况下，方便资源之间的互相通信。如上初中的线程池。

四、优缺点
优点
1、实例控制：单例模式会阻止其他对象实例化其他自己的单例对象的副本，从而确保所有对象都访问唯一实例。
2、灵活性：因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点
1、开销：虽然数量很少，但是如果每次对象请求引用时都检查是否存在类的实例，将仍然需要一些开销，可以通过使用静态初始化解决此问题。
2、可能的开发混淆：使用单例对象（尤其在类库中定义的对象）时，开发人员必须记住自己不能使用new关键字实例化对象，因为可能无法访问库源代码，因为应用程序开发人员可能会意外发现自己无法直接实例化此类。

五、单例模式分为三种
1、饿汉式：类一旦加载，就会实例化这个唯一的对象，不管之后用不用此对象，他都会实例化出来，会占用一定的内存，并且是线程安全的，可以直接应用到多线程场景。
2、懒汉式：类加载期间不会实例化任何实例，而是当调用内部的getInstance()静态方法时，才会进行实例化操作，好比延迟加载，如果要做的工作较多的话，性能上会有些延迟，并且是线程不安全的。
3、枚举法：java1.5后新增枚举，可以实现单例效果。
4、登记式：用的较少，不讲解，自行Google

六、实操
1、饿汉式

package com.designmodel.singleton;

/**
 * 饿汉式单例
 * @author [email protected]
 * @date 2017年3月14日
 */
public class EHSingleton {
    
    //在静态初始化器中创建单例，这样保证了线程安全
    private static final EHSingleton SINGLETON = new EHSingleton();
    
    /*
     * 私有构造器，防止滥new
     */
    private EHSingleton() {
        
    }
    
    /**
     * 获取创建好的实例
     * @return SINGLETON
     */
    public static EHSingleton getInstance() {
        return SINGLETON;
    }
    
}

2、懒汉式

package com.designmodel.singleton;

/**
 * 懒汉式单例
 * @author [email protected]
 * @date 2017年3月14日
 */
public class LHSingleton {
    
    //利用一个静态变量来记录此类的唯一实例
    private static LHSingleton singleton = null;
    
    /*
     * 私有的，防止滥new
     */
    private LHSingleton() {
        
    }
    
    /**
     * 获取实例，懒加载，用的时候才会判断是否需要new，而不是一上来就new
     * @return
     */
    public static LHSingleton getInstance() {
        if(null == singleton) {
            singleton = new LHSingleton();
        }
        return singleton;
    }
}

不难发现，懒汉式存在线程安全问题，我有三种解决办法：
（一）直接同步法

package com.designmodel.singleton;

/**
 * 直接同步法
 * @author [email protected]
 * @date 2017年3月14日
 */
public class ThreadSafeLHSingletonOne {

    //利用静态变量来记录此类的唯一实例
    private static ThreadSafeLHSingletonOne singleton = null;
    
    /*
     * 私有构造器，防止滥new
     */
    private ThreadSafeLHSingletonOne() {
        
    }
    
    /**
     * 直接加同步锁，保证线程安全（效率低）
     * 获取实例，懒加载，用的时候才会判断是否需要new，而不是一上来就new
     * @return
     */
    public static synchronized ThreadSafeLHSingletonOne getInstance() {
        if(null == singleton) {
            singleton = new ThreadSafeLHSingletonOne();
        }
        return singleton;
    }
}

通过增加synchronized关键字到getInstance()方法中，我们迫使每个线程在进入这个方法前，都要先等别的线程离开该方法，这样严重影响了性能（不推荐）。

（二）双重检查加锁

package com.designmodel.singleton;

/**
 * 双重检查加锁
 * @author [email protected]
 * @date 2017年3月14日
 */
public class ThreadSafeLHSingletonTwo {
    
    //利用静态变量来记录此类的唯一实例
    private volatile static ThreadSafeLHSingletonTwo singleton = null;
    
    /*
     * 私有构造器，防止滥new
     */
    private ThreadSafeLHSingletonTwo() {
        
    }
    
    /**
     * 双重检查加锁，保证线程安全（推荐）
     * 获取实例，懒加载，用的时候才会判断是否需要new，而不是一上来就new
     * @return
    */
    public static ThreadSafeLHSingletonTwo getInstance() {
        if(null == singleton) {
            synchronized (ThreadSafeLHSingletonTwo.class) {
                singleton = new ThreadSafeLHSingletonTwo();
            }
        }
        return singleton;
    }
    
}

volatile：确保当singleton变量被初始化时，多个线程正确的处理singleton变量这种方式彻底解决了方式一的那种低调率问题。只有第一次才彻底执行同步的代码。（推荐）。如果不是采用java1.5以及以上版本的话，双重检查加锁实现会失效。

（三）静态内部类方式

package com.designmodel.singleton;

/**
 * 静态内部类方式
 * @author [email protected]
 * @date 2017年3月14日
 */
public class ThreadSafeLHSingletonThree {

    /*
     * 私有构造器，防止滥new
     */
    private ThreadSafeLHSingletonThree() {
        
    }
    
    /**
     * 静态内部类，由于静态内部类只会被加载一次。所以是线程安全的。
     */
    private static class InnerSingleton {
        private static final ThreadSafeLHSingletonThree SINGLETON = new ThreadSafeLHSingletonThree();
    }
    
    /**
     * 静态内部类方式，保证线程安全（极其推荐）
     * 获取实例，懒加载，用的时候才会判断是否需要new，而不是一上来就new
     * @return
     */
    public static final ThreadSafeLHSingletonThree getInstance() {
        return InnerSingleton.SINGLETON;
    }
}

利用静态内部类的机制来初始化实例，静态内部类只有当被调用的时候才开始首次被加载，所以与饿汉式是不同的，一定要注意区别！（极其推荐）

懒汉式和饿汉式都并非绝对安全，通过反射机制，依旧可以实例化多次。（要想防止反射，可以在构造器中判断若多次new，就抛出异常）

3、枚举法

package com.designmodel.singleton;

/**
 * 枚举实现单例
 * @author [email protected]
 * @date 2017年3月14日
 */
public enum EnumSingleton {
    
    INSTANCE; //定义一个枚举的元素，就代表MaYun的一个实例
    
    public void test() {
        System.out.println("Whoa!");
    }
    
    public static void main(String[] args) {
        INSTANCE.test();
    }
}

枚举本身就是单例模式。
避免了反射和反序列化的漏洞。
调用的效率比较高，线程安全，实现简单。
唯一的缺点是没有实现延时加载。

JDK里的单例模式
Runtime

Paste_Image.png

若有兴趣，欢迎来加入群，【Java初学者学习交流群】：458430385，此群有Java开发人员、UI设计人员和前端工程师。有问必答，共同探讨学习，一起进步！
欢迎关注我的微信公众号【Java码农社区】，会定时推送各种干货：

qrcode_for_gh_577b64e73701_258.jpg