Java单例7种测试实践

单例：一个进程中只能存在唯一一个对象。

1.饿汉模式。 主动型太粗暴。

/** * @author ：jiaolian * @date ：Created in 2021-01-10 21:25 * @description：饿汉单例测试 * @modified By： * 公众号:叫练 */public class HungerSignletonTest {    //类初始化会创建单例对象    private static HungerSignletonTest signleton = new HungerSignletonTest();    private HungerSignletonTest(){};    public static HungerSignletonTest getInstance() {        return signleton;    }    public static void main(String[] args) {        //三个线程测试单例,打印hashcode是否一致        new Thread(()->{System.out.println(HungerSignletonTest.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(HungerSignletonTest.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(HungerSignletonTest.getInstance().hashCode()); }).start();    }}

    饿汉模式是主动创建对象，如上面程序代码，JDK1.8环境中主线程启动三个线程获取HungerSignletonTest实例的hashcode是否为同一个对象，测试结果如下图所示，所有的hashcode一致证明程序只有一个实例。饿汉单例在类初始化会提前创建对象。缺点：过早的创建对象需要提前消耗内存资源，我们需要在使用单例对象时再去创建。下面我们看看懒汉模式代码。

2.懒汉模式 线程不安全

/** * @author ：jiaolian * @date ：Created in 2021-01-10 21:39 * @description：懒汉设计模式测试 * @modified By： * 公众号:叫练 */public class LazySignletonTest {    private static LazySignletonTest signleton = null;    private LazySignletonTest(){};    public static LazySignletonTest getInstance() {        if (signleton == null) {            /*try {                //创建对象睡2秒                Thread.sleep(200);            } catch (InterruptedException e) {                e.printStackTrace();            }*/            signleton = new LazySignletonTest();        }        return signleton;    }    public static void main(String[] args) {        //三个线程测试单例        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();    }}

    懒汉模式是需要用到单例才调用getInstance（）方法创建对象，看上去没有什么问题，如果放开上面注释语句，在创建对象睡2秒，可能得到的结果如下图所示，三个线程得到的hashcode的值并不一样，说明signleton对象不是单例。在延迟的情况下，所有线程都会进入if条件语句，所以会有如下情况。缺点：非线程安全，我们需要加一把锁。我们将getInstance()方法改造下，public static synchronized LazySignletonTest getInstance()，用synchronized 修饰下，运行程序，三个线程打印hashcode一致。测试一把，大功告成。还没结束呢？你仔细看下synchronized 修饰的是方法，锁力度会比较大，我们只需要在创建实例对象时加锁就可以了，像我们对追求代码优化极致的程序员必须要“扣”到底。下面我们再来看看用synchronized 修饰单例代码块。

3.懒汉加锁模式  线程还是不安全

/** * @author ：jiaolian * @date ：Created in 2021-01-10 21:39 * @description：懒汉设计模式测试 * @modified By： * 公众号:叫练 */public class LazySignletonTest {    private static LazySignletonTest signleton = null;    private LazySignletonTest(){};    public static LazySignletonTest getInstance() {        if (signleton == null) {            /*try {                //创建对象睡2秒                Thread.sleep(2000);            } catch (InterruptedException e) {                e.printStackTrace();            }*/            synchronized (LazySignletonTest.class) {                signleton = new LazySignletonTest();            }        }        return signleton;    }    public static void main(String[] args) {        //三个线程测试单例        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();    }}

    单次检测加锁模式第一次判断signleton不为空就加锁创建对象，看上去没有什么问题，如果放开上面代码注释，在创建对象睡2秒，可能得到的结果如下图所示，三个线程得到的hashcode的值并不一样，说明signleton对象不是单例，为什么会这样呢？因为三个线程调用Thread.sleep(2000)；会阻塞在创建对象前面，因为三个线程已经判断了signleton等于空，所以都会创建一个新的实例！OK，既然这样，我们就可以在synchronized 同步代码块再加一次判断了，保证万无一失！这是单例双重检测加锁，非常经典的面试题！我们把代码修改成双重检测加锁机制，能万无一失吗？下面我们看代码！事实胜于雄辩！

4.双重检测加锁 指令重排序

/** * @author ：jiaolian * @date ：Created in 2021-01-10 21:39 * @description：懒汉设计模式测试 * @modified By： * 公众号:叫练 */public class LazySignletonTest {    private static LazySignletonTest signleton = null;    private LazySignletonTest(){};    public static LazySignletonTest getInstance() {        if (signleton == null) {            synchronized (LazySignletonTest.class) {                if (signleton == null) {                    signleton = new LazySignletonTest();                }            }        }        return signleton;    }    public static void main(String[] args) {        //三个线程测试单例        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(LazySignletonTest.getInstance().hashCode()); }).start();    }}

    加锁模式第一次判断signleton不为空就加锁创建对象，经过多次测试，hashcode结果一致说明进程中只有一个对象，看上去没毛病！真是这样吗？接下来我们对上面代码再做一次深入测试。

5.双重检测加锁 volatile必要性

import java.util.concurrent.CountDownLatch;/** * @author ：jiaolian * @date ：Created in 2021-01-10 21:39 * @description：没有volatile修饰单例对象测试！ * @modified By：1.堆分配空间 2.初始化构造函数 3.地址指向 * 公众号:叫练 */public class VolatileLockTest {    private static VolatileLockTest signleton = null;    public int aa;    private VolatileLockTest(){        aa = 5;    };    public static VolatileLockTest getInstance() {        if (signleton == null) {            synchronized (VolatileLockTest.class) {                if (signleton == null) {                    signleton = new VolatileLockTest();                }            }        }        return signleton;    }    public static void reset() {        signleton = null;    }    public static void main(String[] args) throws InterruptedException {        //循环三个线程测试单例        while (true) {            CountDownLatch start = new CountDownLatch(1);            CountDownLatch end = new CountDownLatch(100);            for (int i=0;i<100; i++) {                Thread thread = new Thread(()->{                    try {                        //多线程同时等待                        start.await();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    //获取单例，如果锁aa等于0相当于是new 指令重排序了;                    if (VolatileLockTest.getInstance().aa != 5) {                        System.out.println(\"线程终止\");                        System.exit(0);                    }                    end.countDown();                });                thread.start();            }            start.countDown();            end.await();            reset();        }    }}

    如上代码所示：在主程序中死循环创建多线程并发生成单例对象，定义变量“aa”为了测试new VolatileLockTest();对象是否发生重排，new指令一般在JVM中可以分成3步执行：

1. 分配空间。堆上开辟空间。
2. 执行构造函数赋值。调用VolatileLockTest私有构造函数。
3. 将引用指向对象。将signleton指向新的对象。

jvm为了执行效率，可能将2，3重排，执行顺序可能是1->3->2，当多线程并发，就可能出现“aa”不等于5情况，说明了指令如果发生重排，在多线程情况下导致进程会有多个实例，就不符合单例的情况了，正确的情况是将实例变量用volatile修饰，它能够禁止指令重排，也就说new指令必须按照1->2->3顺序执行，这就是volatile修饰对象变量必要性，详细了解volatile特性，请看文章《volatile,synchronized可见性，有序性，原子性代码证明（基础硬核）》，里面有大量实践代码！

6.静态内部类 被动型创建实例（推荐使用）

/** * @author ：jiaolian * @date ：Created in 2021-01-11 15:49 * @description：静态内部类单例模式 * @modified By： * 公众号:叫练 */public class InnerClassSingleton {    private InnerClassSingleton(){};    public static InnerClassSingleton getInstance() {        return InnerClass.innerClassSingleton;    }    private static class InnerClass {        private static InnerClassSingleton innerClassSingleton = new InnerClassSingleton();    }    public static void main(String[] args) {        //三个线程测试单例        new Thread(()->{System.out.println(InnerClassSingleton.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(InnerClassSingleton.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(InnerClassSingleton.getInstance().hashCode()); }).start();    }}

    静态内部类需要用到单例才调用getInstance（）方法创建对象，经过多次测试三个线程得到的hashcode的值是一样，证明signleton对象是单例。代码简单安全是我们推荐使用方案。

7.静态代码块

/** * @author ：jiaolian * @date ：Created in 2021-01-11 16:05 * @description：静态代码块初始单例 * @modified By： * 公众号:叫练 */public class StaticSingleton {    private static StaticSingleton staticSingleton;    //静态代码块初始单例对象.    static {        staticSingleton = new StaticSingleton();    }    //private构造函数    private StaticSingleton(){};    //获取单例静态方法    public static StaticSingleton getInstance() {        return staticSingleton;    }    public static void main(String[] args) {        //三个线程测试单例        new Thread(()->{System.out.println(StaticSingleton.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(StaticSingleton.getInstance().hashCode()); }).start();        new Thread(()->{System.out.println(StaticSingleton.getInstance().hashCode()); }).start();    }}

    如上代码所示，静态代码块会在类初始化调用，3个线程同时获取单例对象，反复测试hashcode值始终保持一致，证明了静态代码块可以实现单例。缺点：主动型创建对象，和“饿汉”单例有点类似。

8.枚举

import java.sql.Connection;/** * @author ：jiaolian * @date ：Created in 2021-01-11 16:39 * @description：枚举单例 * @modified By： * 公众号:叫练 */enum DatabaseFactory {    connectionFactory;    private Connection connection;    private DatabaseFactory(){        System.out.println(\"初始化连接Connection\");        //初始化连接 省略TODO    }    public Connection getConnection() {        return connection;    }    public static void main(String[] args) {        //三个线程测试单例        new Thread(()->{System.out.println(DatabaseFactory.connectionFactory.getConnection()); }).start();        new Thread(()->{System.out.println(DatabaseFactory.connectionFactory.getConnection()); }).start();        new Thread(()->{System.out.println(DatabaseFactory.connectionFactory.getConnection()); }).start();    }}

    如上代码所示，和“饿汉”单例类似。初始化枚举会默认加载构造方法。

总结

    我们说了7种单例用法，总结写法：

• 静态私有变量
• 私有构造方法
• 公有静态获取单例方法

另外我们比较推荐静态内部类方式实现单例，原因是简单和高效，除此之外，我们重点介绍了双重检测加锁实现单例方式，详细说明了里面的坑，并解释了前因后果。如果对你有帮助请点赞加关注哦。我是叫练【公众号】，边叫边练。

遗留问题：在双重检测加锁 volatile必要性中，经过大量测试，始终没有测试出aa不等于5的情况，大佬请留步！！