Java单例7种测试实践
单例：一个进程中只能存在惟一一个对象。java
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 同步代码块再加一次判断了，保证万无一失！这是单例双重检测加锁，很是经典的面试题！咱们把代码修改为双重检测加锁机制，能万无一失吗？下面咱们看代码！事实胜于雄辩！sql
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值始终保持一致，证实了静态代码块能够实现单例。缺点：主动型建立对象，和“饿汉”单例有点相似。jvm
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();
}
}
如上代码所示，和“饿汉”单例相似。初始化枚举会默认加载构造方法。ide
总结
咱们说了7种单例用法，总结写法：
- 静态私有变量
- 私有构造方法
- 公有静态获取单例方法
另外咱们比较推荐静态内部类方式实现单例，缘由是简单和高效，除此以外，咱们重点介绍了双重检测加锁实现单例方式，详细说明了里面的坑，并解释了来龙去脉。若是对你有帮助请点赞加关注哦。我是叫练【公众号】，边叫边练。
遗留问题：在双重检测加锁 volatile必要性中，通过大量测试，始终没有测试出aa不等于5的状况，大佬请留步！！
- 1. 7种Java单例模式
- 2. Java单元测试实践-01.单元测试概述与示例
- 3. Android 单元测试实践
- 4. OpenResty单元测试实践
- 5. Android单元测试实践
- 6. Java版的7种单例模式
- 7. 单元测试实践的主要问题与解决(7)
- 8. 单例的7种写法
- 9. JAVA 单实例最佳实践
- 10. Java的简单单元测试例子
- 更多相关文章...
- • Thymeleaf项目实践 - Thymeleaf 教程
- • PHP 完整表单实例 - PHP教程
- • TiDB 在摩拜单车在线数据业务的应用和实践
- • ☆基于Java Instrument的Agent实现
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 7种Java单例模式
- 2. Java单元测试实践-01.单元测试概述与示例
- 3. Android 单元测试实践
- 4. OpenResty单元测试实践
- 5. Android单元测试实践
- 6. Java版的7种单例模式
- 7. 单元测试实践的主要问题与解决(7)
- 8. 单例的7种写法
- 9. JAVA 单实例最佳实践
- 10. Java的简单单元测试例子