【并发编程】安全发布对象—单例模式升级版

一种错误的发布，当一个对象还没有构造完成时，就使它被其他线程所见

1、发布的对象只需要被它需要的线程被看见

2、避免对象逸出

发布错误对象：

import java.util.Arrays;

//线程不安全的

//发布对象

public class Student {

private String[] student = {“张三”,“李四”,“王五”};

public String[] getStudent(){

return student;

}

public static void main(String[] args) {

Student unsarePublish = new Student();

System.out.println(Arrays.toString(unsarePu

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

浏览器打开：qq.cn.hn/FTf 开源分享

blish.getStudent()));

unsarePublish.getStudent()[1]=“赵柳”;

System.out.println(Arrays.toString(unsarePublish.getStudent()));

}

}

返回结果：

[张三, 李四, 王五]

[张三, 赵柳, 王五]

上述例子中我们可以看到，李四已经被赵柳替代，通过public 类的访问级别，发布了这些域，在外部都可以访问这些域，这样的发布对象其实是不安全的，因为无法假设其他线程会不会修改这个域，所以会导致student的值是不确定的，因此是线程不安全的。

如何来进行安全的发布对象呢：

看了网上好多博客，这里也整理了一下，我们就来使用最经典的，单例模式来设计

1 懒汉模式设计

1.1 懒汉模式

/**

• 懒汉模式

• 线程不安全

*/

public class LazyMode1 {

private LazyMode1(){//私有的构造函数}

private static LazyMode1 instance = null;//单例对象

//在单线程下是没有问题的

public static LazyMode1 getInstance(){

if(instance == null){

instance = new LazyMode1();

}

return instance;

}

}

这是一个比较正常的单例模式的，是一个线程不安全的类，那么如何让他变成一个线程安全的类呢，看下面一个例子

1.2 synchronized

/**

• 懒汉模式

• 线程安全

*/

public class LazyMode2 {

private LazyMode2(){//私有的构造函数}

private static LazyMode2 instance = null; //单例对象

public synchronized static LazyMode2 getInstance(){

if(instance == null){

instance = new LazyMode2();

}

return instance;

}

添加了synchronized后，在同一时间，只能允许一个线程访问，因此可以保证这个是线程安全的

虽然他是线程安全的，但是他带来的性能上的开销，而这个开销是我们不希望的，不推荐使用，别担心下面还有更好的，我们来看下面的知识点

1.3 双重同步锁

/**

• 懒汉模式

• 但是这个类并不是线程安全的类

*/

public class LazyMode3 {

private LazyMode3(){//私有的构造函数}

private static LazyMode3 instance = null; //单例对象

public static LazyMode3 getInstance(){

if(instance == null){

synchronized(LazyMode3.class){

if(instance == null){

instance = new LazyMode3();

}

}

}

return instance;

}

}

这个案例，我们使用了双重同步锁的单例模式，但是他并不是一个线程安全的类，因为在JVM和cpu优化，发生了指令重排，在单线程下，是没有影响的，但是在多线程下，就会打乱分配的内存空间和初始化对象的顺序，就会导致我们的结果和预期的不一致，虽然这个发生的概率很小，但是会发生，所以他是线程不安全的类，那么如何能够让他成为一个线程安全的类呢，看下面的例子。

1.4 volatile+双重同步锁

/**

• 懒汉模式

• 线程安全

*/

public class LazyMode4 {

private LazyMode4(){//私有的构造函数}

private volatile static LazyMode4 instance = null;

public static LazyMode4 getInstance(){

if(instance == null){

synchronized(LazyMode4.class){

if(instance == null){

instance = new LazyMode4();

}

}

}

return instance;

}

}

在这里呢，我们使用了volatile+双重检测机制 他可以禁止指令重排

为什么vloatle可以禁止指令重排？

1、通过加入内存屏障和禁止重排序优化来实现

2、对volatile变量写操作时，会在写操作后加入一条store屏障指令，讲本地内存中的共享变量值刷新到主内存中

3、对volatile变量读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量

2 饿汉模式设计

/**

• 饿汉模式

• 线程安全的

*/

public class HungryMode1 {

private HungryMode1(){//私有的构造函数}

private static HungryMode1 instance = new HungryMode1();//单例对象

public static HungryMode1 getInstance(){

return instance;

}

}

• 饿汉模式的不足：如果饿汉模式中存在过多的处理，会导致这个类在加载的时候特别慢，可能会引起性能问题，如果是只进行类的加载，没有实际的调用的话，会导致资源的浪费

• 所以我们需要考虑的一个点就是肯定会被使用，这样才不会导致过多的浪费，我们来看第二个例子

/**

• 饿汉模式

• 单例实例在类装载时进行创建

*/

@ThreadSafe

public class HungryMode2 {

private HungryMode2(){//私有的构造函数}

//单例对象

private static HungryMode2 instance = null;

//静态代码块

static {

instance = new HungryMode2();

}

public static HungryMode2 getInstance(){

return instance;

}

public static void main(String[] args) {

// System.out.println(getInstance());

// System.out.println(getInstance());

System.out.println(getInstance().hashCode());

System.out.println(getInstance().hashCode());

}

}