前言：金九银十招聘季，这段时间不少小伙伴面试被问到设计模式，其中不泛有让手写一个单例模式，像这种恶心的操作，不得给面试官的秀一手？

概念

所谓单例模式，就是对类要求只能有一个实例，同时该类能自行创建这个实例的模式。

举个简单的例子，如在Windows操作系统中，很多应用程序可以多开，但是任务管理器只能单开，所以任务管理器就是很好的一个单例模式体现。

特点

谈到特点，必须得好好说道说道，就是唬！

• 因内存里只有一个实例，所以可极大的减少了内存开销，避免对资源的多重占用。
• 单例模式一般没有接口，无法有效扩展，除非修改原来的代码，这样原则上违背开闭原则。
• 单例模式的功能模块代码通常封装在一个类中，违背单一职责原则。
• 在并发测试中，如果单例中的代码没有执行完，则不能生成一个新的对象，所以不利于代码的调试。

单例模式实现

单例模式的实现，网上有很多说法，最普遍的就是懒汉式和饿汉式，细分的话，其实懒汉式可以有线程安全和非线程安全两种，同时为了安全和效率还衍生出了双检锁（双重检验锁），最后就是开发中常用的静态内部类，当然还有枚举。

懒汉式（非线程安全）

即懒加载模式，在类加载的时候不生成实例，只有在调用 get() 方法的时候才会生成实例。

public class LazyCase {

    private static LazyCase instance;   	//私有静态单例对象

    private LazyCase(){						//私有构造，避免被外部实例化
        
    };               

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

懒汉式（线程安全）

如果在多线程环境下，当多个线程并行调用 getInstance() 方法的时候，就会创建出多个实例，从而导致出现一些线程不安全的情况，为解决这一点，最简单粗暴的方法就是添加 synchronized 关键字进行同步。

public static synchronized LazyCase getInstance(){		//同步getInstance()方法
    if (instance == null){
            instance = new LazyCase();
    }
    return instance;
}

双检锁

上面的方法虽然保证了线程的安全，避免了创建多个实例，因为程序在运行中任何一个时刻只能有一条线程调用 getInstance() 方法，但是我们的目的是第一次创建单例实例对象的时候需要同步，而后面再次调用 getInstance() 的时候，则不需要线程同步，所以就出现了双检锁的方式。

public class DoubleLockCase {

    private volatile static DoubleLockCase instance;		//声明 volatile
    
    private DoubleLockCase (){
        
    }

    public static DoubleLockCase getInstance() {			//两次判断
        if (instance == null) {
            synchronized (DoubleLockCase.class) {
                if (instance == null) {              
                    instance = new DoubleLockCase();
                }
            }
        }
        return instance;
    }
}

饿汉式

饿汉式的特点就是类一旦加载就会创建一个实例，从而保证在调用 getInstance() 方法之前实例就已经存在，所以它本身就是一种线程安全的方式。

public class HungryCase {

    private static final HungryCase instance = new HungryCase();		//类加载即被初始化

    private HungryCase(){
        
    };

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

静态内部类

饿汉式在某些情况下其实并不理想，如果实例的创建是依赖外部资源的，而调用 getInstance() 方法的时候需传递些数值给它，此时饿汉式就不行了，所以更多情况下会使用静态内部类的方法，因为它没有性能上的缺陷。

public class Case {

    //私有内部类
    private static class InnerCase{             
        private static final Case instance = new Case();
    }

    private Case (){

    }

    public static final Case getInstance() {
        return InnerCase.instance;
    }
}

枚举

枚举就不用多说了，最简单的单例模式。

public enum Case{
    INSTANCE;
}

以上就是所有的单例模式，速速拿下，去征服面试官，从此妈妈再也不用担心被问到单例模式了。

---