java test20006_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步执行：分配空间。堆上开辟空间。
执行构造函数赋值。调用VolatileLockTest私有构造函数。
将引用指向对象。将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的情况，大佬请留步！！
java test20006_Java单例7种测试实践相关推荐
- java的单例设计模式
java的单例设计模式包括:饿汉设计模式和懒汉设计模式: 步骤: 1.创建一个对象把他设置为私有的成员变量,保证唯一 2.私有构造方法,防止new一个对象. 3.定义一个公开的静态方法,返回第一步创建 ...
- Java实现单例的5种方式
转自:https://blog.csdn.net/u014672511/article/details/79774847 1. 什么是单例模式 单例模式指的是在应用整个生命周期内只能存在一个实例.单例 ...
- java 内部类 单例_确保对象的唯一性——单例模式 （四）：一种更好的单例实现方法（静态内部类）...
3.5 一种更好的单例实现方法 饿汉式单例类不能实现延迟加载,不管将来用不用始终占据内存:懒汉式单例类线程安全控制烦琐,而且性能受影响.可见,无论是饿汉式单例还是懒汉式单例都存在这样那样的问题,有没有 ...
- Java实现单例的几种方式
1. 什么是单例模式 单例模式指的是在应用整个生命周期内只能存在一个实例.单例模式是一种被广泛使用的设计模式.他有很多好处,能够避免实例对象的重复创建,减少创建实例的系统开销,节省内存. 2. 单例模 ...
- java 内部类 单例_Java单例模式的几种实现
一:静态内部类实现单例模式 原理:通过一个静态内部类定义一个静态变量来持有当前类实例,在类加载时就创建好,在使用时获取. 缺点:无法做到延迟创建对象,在类加载时进行创建会导致初始化时间变长. publ ...
- java实现单例的5种方法，快收藏
1.饿汉式 饿汉式就是类加载后就创建好了单例,直接拿就行,但该方法容易产生垃圾 public class Singleton1 {//构造器私有化 防止外部实例private Singleton1() ...
- filter java 是单例的吗_JAVA 设计模式之 单例模式详解
单例模式:(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例,并提供一个全局访问点.单例模式是创建型模式.单例模式在现实生活中应用也非常广泛. 在 J2EE 标准中,S ...
- java connection 单例_Java设计模式之单例模式详解
Java设计模式之单例模式详解 什么是设计模式 设计模式是在大量的实践中总结和理论之后优选的代码结构,编程风格,以及解决问题的思考方式.使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可 ...
- java构造单例线程池_java中常见的六种线程池详解
之前我们介绍了线程池的四种拒绝策略,了解了线程池参数的含义,那么今天我们来聊聊Java 中常见的几种线程池,以及在jdk7 加入的 ForkJoin 新型线程池 首先我们列出Java 中的六种线程池如 ...
最新文章
- ORACLE 配置文件
- 关于阿里面试的的一个小题
- Android sendevent/getevent 用法
- 1093 字符串A+B （20 分）
- 小白零基础怎么学习Java？不要慌
- linux 命令 kps,Linux顶级命令.内存使用情况
- 如何在Java中将集合转换为列表
- html桌面程序实例spark,【01】Spark 简单实例
- 计算机屏幕画图工具,电脑屏幕画笔工具(Pointofix)
- 【无线通信协议笔记】蓝牙篇:传输速率
- c语言第六版题目,C primer plus 第六版 第6版 002章 第二章 复习题 答案 中文
- 【光学】干涉衍射仿真含Matlab源码
- Hybird App开发，懂得小程序+kbone+finclip就够了！
- 数据架构选型必读：2021上半年数据库产品技术解析
- 中英文标点符号转换-在线工具
- 阿卡索口语学习（Learn And Talk 0)短语及单词（二）
- iOS中 @synthesize 和 @dynamic 区别
- 计算机四级网络工程师
- SAS数据步与过程步，数据步语句
- MapX编程详解(C++)----MapX发布技术