Java并发编程 (五) 线程安全性

我的博客网：https://wushaopei.github.io/    (你想要这里多有)

1、安全发布对象-发布与逸出

一、发布与逸出定义

发布对象 ： 使一个对象可以被当前范围以外的代码所使用

对象逸出： 一种错误的发布。当一个对象尚未构造完成时，就使它被其余线程所见。

二、开发工做中涉及到的发布对象：

好比经过类的非私有方法，返回对象的引用；或者经过共有静态变量发布对象。

三、发布对象代码演示：

package com.mmall.concurrency.example.publish; import com.mmall.concurrency.annoations.NoThreadSafe; import lombok.extern.slf4j.Slf4j; import java.util.Arrays; /** * @ClassName UnsafePublish * @Description TODO * @Author wushaopei * @Date 2019/10/31 15:28 * @Version 1.0 */ @Slf4j @NoThreadSafe public class UnsafePublish { private String [] states = {"a","b","c"}; public String [] getStates(){ return states; } public static void main(String[] args) { UnsafePublish unsafePublish = new UnsafePublish(); log.info("{}", Arrays.toString(unsafePublish.getStates())); //对私有属性数组进行修改 unsafePublish.getStates()[0] = "d"; log.info("{}",Arrays.toString(unsafePublish.getStates())); } }

执行结果：

15:31:56.516 [main] INFO com.mmall.concurrency.example.publish.UnsafePublish - [a, b, c]
15:31:56.521 [main] INFO com.mmall.concurrency.example.publish.UnsafePublish - [d, b, c]

Process finished with exit code 0

分析：

经过public 的getStates方法发布了访问states的域，这样任何的外部线程均可以修改这个域，这样的发布对象实际上是不安全的，由于没法假设其余线程会不会修改这个域，从而形成类里面这个状态的错误。

简单来讲，这里经过new UnsafePublish()发布了这个类的实例，而后咱们能够经过它提供给咱们的public方法直接获得里面这个私有域states的引用，获得后咱们就能够在其余的任何线程里面修改这个数组里面的值，这样一来，当我想要使用states里面的数据时，这时它里面的数据就是不彻底肯定的，所以，这样发布的对象就是线程不安全的。

四、对象逸出代码演示：

package com.mmall.concurrency.example.publish; import com.mmall.concurrency.annoations.NoRecommend; import com.mmall.concurrency.annoations.NoThreadSafe; import com.sun.org.apache.bcel.internal.classfile.InnerClass; import lombok.extern.slf4j.Slf4j; /** * @ClassName Escape * @Description TODO * @Author wushaopei * @Date 2019/10/31 15:39 * @Version 1.0 */ @Slf4j @NoThreadSafe @NoRecommend public class Escape { private int thisCanBeEscape = 0; public Escape(){ new InnerClass(); } private class InnerClass{ public InnerClass (){ log.info("{}",Escape.this.thisCanBeEscape); } } public static void main(String[] args) { new Escape(); } }

执行结果：

15:41:32.697 [main] INFO com.mmall.concurrency.example.publish.Escape - 0

Process finished with exit code 0

分析：

这个内部类的实例当中，包含了对封装、实例、隐含和引用，这样实例在没有被构造完成以前就会被发布，可能有不安全的因素在里面。

可能致使this函数引用在构造过程当中逸出的错误：

一个线程不管隐式的启动仍是显式的启动，都会形成this引用的逸出；新线程总会在所属构造完毕以前就看到它过时的值。因此，要在构造函数中构造线程，那么不要启用它，而是采用一个start或专有的初始化方法来统一启动线程，这里可使用工厂方法和私有构造函数来完成对象建立和监听器的注册等等，从而避免不肯定的建立。

发布不肯定对象会致使的错误：

发布线程之外的全部线程均可以看到被发布对象的过时的值；

线程看到的被发布对象的引用是最新的，然而被发布对象的状态倒是过时的

注意：若是一个对象是可变对象，那么它就要安全发布才能够。

2、安全发布对象-四种方法-1

一、安全发布对象的四种方法：

•  在静态初始化函数中初始化一个对象引用；
•  将对象的引用保存到volatile类型域或者AtomicReference对象中；
•  将对象的引用保存到某个正确构造对象的final类型域中；
•  将对象的引用保存到一个由锁保护的域中。

二、使用代码演示安全发布对象的四种方法：

1） 线程不安全的单例-懒汉式

/* * 懒汉模式 * 单例实例在第一次使用的时候进行建立 * */ @NoThreadSafe public class SingletonExample1 { //私有构造函数 private SingletonExample1(){ } //单例对象 private static SingletonExample1 instance = null; //静态的工厂方法 public static SingletonExample1 getInstance(){ if (instance == null){ instance = new SingletonExample1(); } return instance; } }

注意：懒汉模式是线程不安全的。

2） 饿汉式

/* * 饿汉模式 * 单例实例在类装载的时候进行建立 * */ @ThreadSafe public class SingletonExample2 { //私有构造函数 private SingletonExample2(){ } //单例对象 private static SingletonExample2 instance = new SingletonExample2(); //静态的工厂方法 public static SingletonExample2 getInstance(){ return instance; } }

饿汉模式是线程安全的，可是，若是私有构造方法中的操做太多，会形成加载时间过长；同时因为随着类装载，若是没有使用到该类的实例，会致使资源的浪费。

3）安全的懒汉式：

//静态的工厂方法 public static synchronized SingletonExample3 getInstance(){ if (instance == null){ instance = new SingletonExample3(); } return instance; }

注意：虽然这么添加同步锁后，线程安全了，可是会致使开销的增长，对性能有很大影响，不推荐这么操做。

4)使用synchronized对象锁修饰懒汉模式：

/* * 懒汉模式 ->>双重同步锁单例 * 单例实例在第一次使用的时候进行建立 * */ @NoThreadSafe public class SingletonExample4 { //私有构造函数 private SingletonExample4(){ } //单例对象 private static SingletonExample4 instance = null; //静态的工厂方法 public static SingletonExample4 getInstance(){ if (instance == null){ //双重检测机制 synchronized (SingletonExample4.class){ //同步锁 if(instance == null ){ instance = new SingletonExample4(); } } } return instance; } }

问题：这里虽然使用了同步锁机制，可是依然是线程不安全的，为何呢？

这里要从CPU的指令分析：

1. memory = allocate() 分配对象的内存空间
2. ctorInstance() 初始化对象
3. Instance = memory 设置instance 指向刚分配的内存

在完成以上三步后，instance就指向了实际分配内存的地址，也就是引用。在单线程状况下，执行CPU指令操做后，返回对象实例，是没有任何问题的。

可是，在多线程状况下，因为CPU存在指令重排序的问题，指令重排序对单线程是没有影响的，可是在多线程状况下就不必定了。

当JVM和CPU优化，发生了指令重排后,上面的执行顺序发生了变化：

 1. memory = allocate() 分配对象的内存空间

 2.Instance = memory 设置instance 指向刚分配的内存

 3.ctorInstance() 初始化对象

如上，指令2和指令3发生了重排。

由重排序后的指令顺序可知，当线程执行到instance == null的判断时，此时因为指令3先执行了，那么instance就会认为当前的instance已经实例化过了，而后就会返回instance的实例；然而，此时的指令2并无执行初始化对象，那么，一旦发生调用instance实例的操做，那么就会发生错误。

3、安全发布对象-四种方法-2

解决指令重排的问题：

一、使用volatile来修饰变量：

//单例对象 volatile + 双重检测机制 - 》 进制指令重排
private volatile static SingletonExample5 instance = null;

volatile能够制止CPU进行指令重排序的发生。

二、使用静态域、静态代码块实例化饿汉模式：

/* * 饿汉模式 * 单例实例在类装载的时候进行建立 * */ @ThreadSafe public class SingletonExample6 { //私有构造函数 private SingletonExample6(){ } //单例对象 private static SingletonExample6 instance = null; static { instance = new SingletonExample6(); } //静态的工厂方法 public static SingletonExample6 getInstance(){ return instance; } public static void main(String[] args) { System.out.println(getInstance().hashCode()); System.out.println(getInstance().hashCode()); System.out.println(getInstance().hashCode()); System.out.println(getInstance().hashCode()); } }

执行结果：

1450495309
1450495309
1450495309
1450495309

Process finished with exit code 0

注意：当咱们在写静态域以及静态代码块时必定要注意他们的顺序，顺序不一样，执行的结果也会不一样。

不一样的静态代码块是按照顺序执行，与普通的方法、代码块是不一样的。

三、使用枚举实现一个线程安全的单例模式：

/** * 枚举模式：最安全 * */ @ThreadSafe @Recommend public class SingletonExample7 { // 私有构造函数 private SingletonExample7() { } public static SingletonExample7 getInstance() { return Singleton.INSTANCE.getInstance(); } private enum Singleton { INSTANCE; private SingletonExample7 singleton; // JVM保证这个方法绝对只调用一次 Singleton() { singleton = new SingletonExample7(); } public SingletonExample7 getInstance() { return singleton; } } }

枚举实现的单例比懒汉式线程要安全的多，同时，因为JVM的特性，在调用的时候才执行，也只执行一次，避免了重复执行形成的安全问题。避免了资源的浪费。

小结：

  安全发布对象 - 发布、逸出

  安全发布的四中方法 ： 饿汉式、volatile、枚举