Java单例7种测试实践

最新推荐文章于 2024-10-24 10:17:08 发布
置顶 最新推荐文章于 2024-10-24 10:17:08 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： Java基础 多线程 学习 文章标签： 设计模式 面试 单例模式 双重加锁 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duyabc/article/details/112506690
版权
学习 同时被 3 个专栏收录
23 篇文章 1 订阅
订阅专栏
多线程
17 篇文章 0 订阅
订阅专栏
Java基础
13 篇文章 0 订阅
订阅专栏

目录

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

2.懒汉模式 线程不安全

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

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

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

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

7.静态代码块

8.枚举

总结

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

 

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

Java创建型设计模式-单例模式
欢迎拜读我的作品，喜欢的领域请给我留言
08-10 1885
好啦，以上就是关于java设计模式的单例模式详细介绍，整理出八种初始化方式及其利弊分析，最佳方式推荐是3.4章节的线程安全单例。
java 单例继承_单例模式中子类如何继承其父类
weixin_28964423的博客
02-21 1084
转自http://blog.csdn.net/wuzhekai1985/article/details/6665869软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大...
Java设计模式圣经连载（04）－单例模式
weixin_33924312的博客
09-11 141
Java设计模式圣经连载（04）－单例模式   单例模式是一种常见的设计模式，在《Java与模式》一书中，阎宏博士对单例模式做了全面的总结。 单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。   单例模式有一下特点： 1、单例类只能有一个实例。 2、单例类必须自己自己创建自己的唯一实例。 3、单例类必须给所有其他对象提供这一实例。   说明：一下的代码来自阎宏博士的《J...
JAVA单例设计测试
一梦晓三生的博客
07-21 190
单例demo package cgb.java.model.singleton; import java.util.ArrayList; import java.util.List; /** * 需求：设计一个类，保证此类的实例在一个JVM内部只有一份 */ class Singleton01{//此设计在多线程环境中存在不安全 private Singleton01(){} privat...
Java基础面试题以及几个很有用的刷题网站.docx
06-13
该文档有java面试题以及答案，还有算法、架构、线程等面试题，文档末提供了几个很全的网址，word中有题和答案的只是基础，其他的可在三个网址中查看
java junit测试例_关于java：使用jUnit测试单例
weixin_33877981的博客
02-24 376
我有一个工厂类来检索我的应用程序的配置：public class ConfigurationFactory {private static ConfigurationFactory configurationFactory = new ConfigurationFactory();private Configuration configuration = null;public static Co...
使用Java单例模式实现一个简单的日志记录器.txt
08-17
本文介绍了一种使用Java单例模式实现简单日志记录器的方法。通过定义静态变量、私有构造函数以及线程安全的实例获取方法，实现了日志记录器的单例模式。此外，还提供了写入日志的方法，便于实际应用中的日志管理。...
Java单例模式解析：懒汉式与饿汉式
"Java单例模式分为懒汉式单例、饿汉式单例和登记式单例三种，是设计模式中的常见类型，用于确保一个类只有一个实例并提供全局访问点。这种模式由《Java与模式》的作者阎宏博士进行了深入的探讨。" 在Java编程中，...
Java刷题、面试网站
Brave_heart4pzj的博客
07-15 297
https://blog.csdn.net/qq_39597203/article/details/87040973
java sample测试案例
12-12
java 定义模板生成word，word转换pdf,dwr半反推测试，其中使用word转换pdf使用jacob时需要office2007（需要安装发布pdf或xps插件）以上版本，使用dwr半推时可以模拟两个不同浏览器使用servlet(Main)建立会话发送格式为用户标识：message
java通用测试用例
11-10
java通用测试用例java通用测试用例java通用测试用例java通用测试用例
java测试单个方法 @Test
热门推荐
liufuwang007的博客
08-27 3万+
今天分享给大家的是Java 中“测试单个方法运行”的方法。@Test 关键字的包：import org.junit.Test; 导入包后，我们可以在每个无参方法的上一行添加关键字。 注意: 1.不能在类前用 2.不能在有参数的方法前用如果测试有参函数的话，可以暂时屏蔽参数,定义局部变量来代替参数。示例代码：@Test public void showMainView(){ whil
java单例模式在多线程环境下的测试
zhanweichun的专栏
07-23 266
java单例模式在多线程环境下的测试,进攻自己学习和复习用. 1. 不加双重判断, 会生成2个不同的对象. 代码如下:   package com.thred; import java.util.Date; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; p...
JAVA 单例模式实验（头歌）
最新发布
Dr_icewine的博客
10-24 458
本任务有三个文件“Login.java”、“Client.java”和“Singleton.java”，在右侧编辑器 Begin-End 内补充 Singleton 中代码，其它文件请阅读代码。在企业网站后台系统中，一般会将网站统计单元进行独立设计，比如登录人数的统计、IP 数量的计数等。在这类需要完成全局统计的过程中，就会用到单例模式，即整个系统只需要拥有一个计数的全局对象。该方法会在首次被调用时创建一个新对象， 并将其存储在静态成员变量中。类的静态方法仍能调用构造函数， 但是其他对象不能调用。
刷题、面试必备网站(java)
m0_54866636的博客
08-28 216
整理的一些刷题面试的网站，做一个汇总，分久必合。
Java编写测试用例
纵与横的博客
06-19 2万+
题目： 购物车需求 ShoppingCart类的主要功能是能增加和删除商品。增加的商品可以是null。 针对它的addItems和deleteItems编写单元测试。API说明如下: /** * 增加商品到购物车 * @param item * @param count * @throws NegativeCountException count为负数时，抛NegativeCount...
Java基础--单例类创建和测试
weixin_30571465的博客
09-03 223
单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。单例模式有很多好处，它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。 如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，那么单例模式也许是一个值得考虑的选择。一些管理器和控制器常被设计成单例模式。 实现1-普通 publ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值