写点什么

Java 单例 7 种测试实践

用户头像
叫练
关注
发布于: 2021 年 01 月 12 日
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 一致证明程序只有一个实例。饿汉单例在类初始化会提前创建对象。缺点过早的创建对象需要提前消耗内存资源,我们需要在使用单例对象时再去创建。下面我们看看懒汉模式代码。

image.png


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 修饰单例代码块。


image.png


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 同步代码块再加一次判断了,保证万无一失!这是单例双重检测加锁,非常经典的面试题!我们把代码修改成双重检测加锁机制,能万无一失吗?下面我们看代码!事实胜于雄辩!


image.png


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 结果一致说明进程中只有一个对象,看上去没毛病!真是这样吗?接下来我们对上面代码再做一次深入测试


image.png


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 的情况,大佬请留步!!


image.png


发布于: 2021 年 01 月 12 日阅读数: 11
用户头像

叫练

关注

我是叫练,边叫边练 2020.06.11 加入

Java高级工程师,熟悉多线程,JVM

评论

发布
暂无评论
Java单例7种测试实践