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

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

[] ) [](top

原文创作:叫练

原文链接:https://www.cnblogs.com/jiaolian/p/14265601.html

文章列表

更多推荐

更多
  • Ansible2实战-五、消费和创建模块 技术要求,使用命令行执行多个模块,查看模块索引,从命令行访问模块文档,模块返回值,开发定制模块,避免常见的陷阱,测试和记录您的模块,模块清单,向上游投稿–提交 GitHub 拉取请求,摘要,发现插件类型,问题,进一步, 在这本书里
    Apache CN

  • Ansible2实战-十、容器和云管理 技术要求,使用行动手册设计和构建容器,管理多个容器平台,使用可扩展容器部署到 Kubernetes,用 Ansible 管理 Kubernetes 对象,安装 Ansible 的库本内特依赖项,用 Ansible 列出 Kubernet
    Apache CN

  • Ansible2实战-九、使用 Ansible 的网络自动化 技术要求,为什么要自动化网络管理?,了解 ansible 如何管理网络设备,实现网络自动化,查看可用的 Ansible 网络模块,连接到网络设备,网络设备的环境变量,网络设备的条件语句,摘要,问题,进一步, 多年前,标准做法是手工
    Apache CN

  • Ansible2实战-十二、Ansible Tower 入门 技术要求,安装 AWX,运行你的第一个剧本从 AWX,创建 AWX 项目,创建库存,创建作业模板,运行作业,控制进入 AWX,创建用户,创建团队,创建组织,在 AWX 分配权限,摘要,问题, Ansible 非常强大,但它确实需要
    Apache CN

  • Ansible2实战-十一、故障排除和测试策略 技术要求,挖掘行动手册执行问题,使用主机事实诊断故障,用剧本测试,使用检查模式,解决主机连接问题,通过命令行界面传递工作变量,限制主机的执行,刷新代码缓存,检查错误的语法,摘要,问题,进一步, 与任何其他类型的代码类似,Ansib
    Apache CN

  • Ansible2实战-第三部分:在企业中使用 Ansible 在本节中,我们将从实际出发,看看如何在企业环境中最大限度地利用 Ansible。在开始使用 Ansible 管理云和容器环境之前,我们将首先了解如何使用 Ansible 自动化您的网络设备。然后,我们将了解一些更高级的测试和故障
    Apache CN

  • Ansible2实战-第二部分:扩展 Ansible 的能力 在这一节中,我们将介绍 Ansible 插件和模块的重要概念。我们将讨论它们的有效使用,以及如何通过编写自己的插件和模块来扩展 Ansible 的功能。我们甚至会考虑将您的模块和插件提交回官方 Ansible 项目的要求。我们还
    Apache CN

  • Ansible2实战-第一部分:学习 Ansible 的基础知识 在本节中,我们将了解 Ansible 的基本原理。我们将从安装 Ansible 的过程开始,然后我们将掌握基础知识,包括语言和特殊命令的基础知识。然后,我们将探索 Ansible 清单,然后再考虑编写我们的第一个行动手册和角色来
    Apache CN

  • Ansible2实战-十三、答案 第一章,第二章,第三章,第四章,第五章,第六章,第七章,第八章,第九章,第十章,破产重组保护,第十二章,第一章1.甲,乙 2.C 3.A 第二章1.C 2.B 3.A 第三章1
    Apache CN

  • Ansible2实战-八、高级 Ansible 主题 技术要求,异步与同步操作,控制滚动更新的播放执行,配置最大故障百分比,设置任务执行委托,使用一次性运行选项,在本地运行行动手册,使用代理和跳转主机,在游戏和任务中放置标签,使用可加密保管库保护数据,摘要,问题,进一步, 到目前为止
    Apache CN

  • 近期文章

    更多
    文章目录

      推荐作者

      更多