JAVA单例模式详解

什么是单例模式：单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并
提供一个全局访问点。单例模式是创建型模式。

单例模式的应用场景：在J2EE 标准中， ServletContext 、ServletContextConfig 等；在Spring 框架应用中ApplicationContext；数据库的连接池也都是单例形式。

一、饿汉式单例：饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题。
优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。
缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存。

Spring 中IOC 容器ApplicationContext 本身就是典型的饿汉式单例；接下来看一段代
码：

public class HungrySingleton {
    //先静态、后动态
    //先属性、后方法
    //先上后下
    private static final HungrySingleton hungrySingleton = new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance(){
    return hungrySingleton;
    }
}

还有另外一种写法，利用静态代码块的机制：

//饿汉式静态块单例
public class HungryStaticSingleton {
    private static final HungryStaticSingleton hungrySingleton;
    static {
        hungrySingleton = new HungryStaticSingleton();
    }
    private HungryStaticSingleton(){}
    public static HungryStaticSingleton getInstance(){
        return hungrySingleton;
        }
    }
}

这两种写法都非常的简单，也非常好理解，饿汉式适用在单例对象较少的情况。

下面我们来看性能更优的写法。

二、懒汉式单例

懒汉式单例的特点是：被外部类调用的时候内部类才会加载，下面看懒汉式单例的简单
实现LazySimpleSingleton：

//懒汉式单例
//在外部需要使用的时候才进行实例化
public class LazySimpleSingleton {
    private LazySimpleSingleton(){}
    //静态块，公共内存区域
    private static LazySimpleSingleton lazy = null;
    public static LazySimpleSingleton getInstance(){
    if(lazy == null){
        lazy = new LazySimpleSingleton();
    }
        return lazy;
    }
}

然后写一个线程类ExectorThread 类：

public class ExectorThread implements Runnable{
    @Override
    public void run() {
        LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + singleton);
    }
}

客户端测试代码：

public class LazySimpleSingletonTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
        System.out.println("End");
    }
}

JAVA单例模式详解

一定几率出现创建两个不同结果的情况，意味着上面的单例存在线程安全隐患。现在我们用调试运行再具体看一下，教给大家一个新技能，用线程模式调试，手动控制线程的执行顺序来跟踪内存的变化状态。先给ExectorThread 类打上断点，右键点击断点，切换为Thread 模式，如下图：

JAVA单例模式详解

然后，给LazySimpleSingleton 类打上断点，同样标记为Thread 模式：

JAVA单例模式详解

切回到客户端测试代码，同样也打上断点，同时改为Thread 模式，如下图:

JAVA单例模式详解

开始debug 之后，会看到debug 控制台可以自由切换Thread 的运行状态：

JAVA单例模式详解

通过不断切换线程，并观测其内存状态，我们发现在线程环境下LazySimpleSingleton，被实例化了两次。有时，我们得到的运行结果可能是相同的两个对象，实际上是被后面执行的线程覆盖了，我们看到了一个假象，线程安全隐患依旧存在。那么，我们如何来优化代码，使得懒汉式单例在线程环境下安全呢？来看下面的代码，给getInstance()加上synchronized 关键字，是这个方法变成线程同步方法：

public class LazySimpleSingleton {
    private LazySimpleSingleton(){}
    //静态块，公共内存区域
    private static LazySimpleSingleton lazy = null;
    public synchronized static LazySimpleSingleton getInstance(){
    if(lazy == null){
        lazy = new LazySimpleSingleton();
    }
    return lazy;
    }
}

这时候，我们再来调试。当我们将其中一个线程执行并调用getInstance()方法时，另一个线程在调用getInstance()方法，线程的状态由RUNNING 变成了MONITOR,出现阻塞。直到第一个线程执行完，第二个线程才恢复RUNNING 状态继续调用getInstance()方法。完美的展现了synchronized 监视锁的运行状态，线程安全的问题便解决了。但是，用synchronized 加锁，在线程数量比较多情况下，如果CPU 分配压力上升，会导致大批量线程出现阻塞，从而导致程序运行性能大幅下降。

三、双重检查锁+volatile的单例模式：

public class LazyDoubleCheckSingleton {
        private volatile static LazyDoubleCheckSingleton lazy = null;
        private LazyDoubleCheckSingleton(){}
        public static LazyDoubleCheckSingleton getInstance(){
        if(lazy == null){
            synchronized (LazyDoubleCheckSingleton.class){
        if(lazy == null){
            lazy = new LazyDoubleCheckSingleton();
            //1.分配内存给这个对象
            //2.初始化对象
            //3.设置lazy 指向刚分配的内存地址
            }
        }
        }
        return lazy;
    }
}

调试线程，当第一个线程调用getInstance()方法时，第二个线程也可以调用getInstance()。当第一个线程执行到synchronized 时会上锁，第二个线程就会变成MONITOR 状态，出现阻塞。此时，阻塞并不是基于整个LazySimpleSingleton 类的阻塞，而是在getInstance()方法内部阻塞，只要逻辑不是太复杂，对于调用者而言感知不到。但是，用到synchronized 关键字，总归是要上锁，对程序性能还是存在一定影响的

四、Holer方式的单例模式：

holder方式完全借助了类加载的特点，采用静态内部类的方式：

//这种形式兼顾饿汉式的内存浪费，也兼顾synchronized 性能问题
//完美地屏蔽了这两个缺点
public class LazyInnerClassSingleton {
//默认使用LazyInnerClassGeneral 的时候，会先初始化内部类
//如果没使用的话，内部类是不加载的
    private LazyInnerClassSingleton(){}
    //每一个关键字都不是多余的
    //static 是为了使单例的空间共享
    //保证这个方法不会被重写，重载
    public static final LazyInnerClassSingleton getInstance(){
        //在返回结果以前，一定会先加载内部类
        return LazyHolder.LAZY;
    }
    //默认不加载
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

在LazyInnerClassSingleton中没有 LAZY的静态成员，而是放入到LazyHolder 内部类中，因此在LazyInnerClassSingleton初始化的时候并不会创建 LazyInnerClassSingleton实例，LazyHolder中定义了LazyInnerClassSingleton的静态变量并实例化，只有当LazyHolder被主动引用时才去创建LazyInnerClassSingleton实例，内部类一定是要在方法调用之前初始化，巧妙地避免了线程安全问题。

五枚举方式的单例：

枚举类型不允许被继承，同样是线程安全的且只能被实例化一次，但是枚举不能够懒加载。

public enum EnumSingleton {
        INSTANCE;
    private byte [] data =new byte[1024];
    
    public static EnumSingleton getInstance(){
        return INSTANCE;
    }
}

但是我们可以通过改造，增加懒加载特性，代码如下：

public calss EnumSingleton {
        
    private EnumSingleton (){}
    private enum EnumHoler{
        INSTANCE;
        private EnumSingleton singleton;
        EnumHoler(){
            this.singleton=new EnumSingleton ();
        }
        private  EnumSingleton  getSingleton(){
            return singleton;
        }
    }

    public static EnumSingleton getInstance(){
        return EnumHoler.INSTANCE.getSingleton();
    }
}

参考资料来自沽泡学院TOM老师