玩转多线程–解决线程安全（超详细讲述八锁问题！！！）

目录

前言：

解决线程安全策略

1线程是抢占式执行的

2多个线程修改同一个变量

3原子性

4内存可见性

5指令重排序 有序性

synchronized关键字 – 监视锁 monitor lock

synchronized的特性

1）具有互斥性

2）实现了原子性问题

代码示例1：

画图解析1：

代码示例2：

画图解析2：

总结：

3）实现内存可见性

4）具有可重入性

解释：

代码示例：

5）锁对象唯一性

理解阻塞等待：

注意：

6）没有禁止指令重排序

synchronized的使用（八锁现象）重点！！！

1）执行不同对象的synchronized方法，修改全局变量

2）使用this作为锁对象

3）使用单独的锁对象

4）在多个实例中使用单独的锁对象

5）使用静态全局对象为锁对象

6）单个实例中，创建两个方法，使用同一个锁对象

7）使用类对象作为锁对象

8）使用String.class作为锁对象

总结：

volatile关键字

1）解决内存可见性

Java层面解决内存可见性

内存屏障

屏障的类型（四种）

2）解决指令重排序问题

3）volatile不保证原子性

总结

经典例题

面试题

---

前言：

关于多线程创建和造成线程安全的原因，博主已经在前面的玩转多线程–入门-CSDN博客有详细介绍哦，大家可以直接点击链接进入阅读！！

解决线程安全策略

1线程是抢占式执行的

CPU调度方式的问题，硬件层面的，我们无法解决

2多个线程修改同一个变量

在真实业务场景中，使用多线程就是为了提升效率，在并发编程中需要满足多线程修改同一变量的需求

3原子性

指令是在CPU上执行的，可以解决

4内存可见性

Java层面可以解决

进程间可以通信，那么线程中应该也有这样的机制，让线程在内存中可以彼此感知

5指令重排序 有序性

从程序员层面可以通过某种方式告诉编译器，不要对我们代码进行重排序

注意：对于后三条，我们满足其中一条或者多条，线程安全问题就可以解决

synchronized关键字 – 监视锁 monitor lock

synchronized的特性

1）具有互斥性

synchronized会起到互斥效果，某个线程执行到某个对象的synchronized中的时候，其他线程如果也想执行同一个对象synchronized的时候就会发生阻塞等待

进入synchronized修饰的代码块，相当于加锁

退出synchronized修饰的代码块，相当于解锁

2）实现了原子性问题

代码示例1：

下面代码执行的是一个不加锁的执行count++的操作

 int count = 0;
 count++;

画图解析1：

注：t1、t2代表两个不同线程

LOAD：从主内存中加载到工作内存

ADD：进行自增操作

STORE：写回主内存

代码示例2：

下面是加锁的count++操作

 int count = 0;
 Object locker = new Object();
 synchronized (locker){
     count++;
 }

画图解析2：

总结：

由上述代码转化为指令执行，可以明白t2线程只能等到加锁的t1线程全部执行完毕并且释放锁，才能加锁再执行t2的操作

保证原子性指的是所有的指令不执行完毕不会释放锁，但是中途指令可以调出CPU

注意：不要将锁定和CPU调度搞混！！！

3）实现内存可见性

根据博主玩转多线程 — 初阶的JMM模型来分析

由于线程在执行逻辑之前要拿到锁，当拿到锁的时候，上一个线程已经执行完所有的指令释放锁，并且把处理完毕的数据刷新回主内存，当前线程读到的永远是上一个线程处理完毕之后的数据

因为加锁实现了原子性，所以后一个线程永远读到的是上一个线程处理完毕的数据，并且该数据已经放回主内存中，主内存相当于一个交换空间，实现了线程依次读取，因此侧面实现了内存可见性问题 (并没有对内存可见性做任何技术上的处理)

这个“侧面”指的是通过原子性和顺序执行来实现的

4）具有可重入性

synchronized同步块对同一线程来说是可重入的，不会出现把自己锁死的情况

解释：

某个线程加锁的时候，发现锁已经被别人占用，但是恰好是自己，那么仍然可以继续获取到锁，并且有内置的计数器++

解锁的时候计数器递减为0的时候，才真正释放锁（才能真正被别的线程获取到）

代码示例：

 int count = 0;
 Object locker = new Object();
 for (int i = 0; i < 1000; i++) {
     synchronized (locker){
         synchronized (locker){
             count++;
         }
     }
 }

5）锁对象唯一性

不同的锁对象不存在竞争关系，会产生线程安全问题

任何对象都可以作为锁对象，只要线程访问的锁对象是同一个，那么它们就存在竞争关系

理解阻塞等待：

针对每一把相同的锁，操作系统内部维护了一个等待队列，当这个锁为某个线程所占有时，其它线程尝试进行加锁，就加不上了，就会阻塞等待，一直等到之前的线程解锁之后，有操作系统唤醒一个新的线程再来获取这个锁

注意：

上一个线程解锁之后，下一个线程并不是立即就能得到锁，而是要靠操作系统来“唤醒”，这也就是操作系统线程调度的一部分工作

假设有 A B C三个线程，线程A先获取到锁，然后B尝试获取锁，然后C再尝试获取锁，此时B和C都在阻塞队列中排队等待，但是当A释放锁之后，虽然B比C先来，但是B不一定就能获取到锁，而是和C重新竞争，并不遵循先来后到的规则

6）没有禁止指令重排序

synchronized的使用（八锁现象）重点！！！

1）执行不同对象的synchronized方法，修改全局变量

 public class Test1 {
     public static void main(String[] args) throws InterruptedException {
         //初始化累加对象
         Counter counter1 = new Counter();
         Counter counter2 = new Counter();
         //创建两个线程对同一个变量进行累加
         Thread t1 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter1.increase();//锁对象就是counter1
             }
         });
         //启动线程
         t1.start();
 ​
         Thread t2 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter2.increase();//锁对象就是counter2
             }
         });
         //启动线程
         t2.start();
 ​
         t1.join();
         t2.join();
         System.out.println("count=" + Counter.count);
     }
 }
 //创建一个专门用来累加的类
 class Counter{
     public static int count = 0;
     //synchronized修饰方法时，锁对象就是当前对象
     public synchronized void increase(){
         count++;
     }
 }

最终count结果不符合预期值100000，因此发生了线程安全问题！！！

原因：这两个所对象不是同一个实例，也意味着两个线程锁对象不同，因此不发生锁竞争

2）使用this作为锁对象

我们可以借助第一种现象的代码，将其increase方法部分做了小小的修改，因为锁对象是this，所以每一次实例一个对象，this就会指向新的对象，因此this锁对象不唯一，会发生线程安全问题！！！！

3）使用单独的锁对象

 public class Test2 {
     public static void main(String[] args) throws InterruptedException {
         //初始化累加对象
         Counter01 counter01 = new Counter01();
         //创建两个线程对同一个变量进行累加
         Thread t1 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter01.increase();
             }
         });
         //启动线程
         t1.start();
 ​
         Thread t2 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter01.increase();
             }
         });
         //启动线程
         t2.start();
 ​
         t1.join();
         t2.join();
         System.out.println("count01:" + Counter01.count01);
     }
 }
 ​
 class Counter01{
     public static int count01 = 0;
     //单独定义一个对象为锁对象使用
     Object locker = new Object();
     /**
      * 简单累加方法
      */
     public void increase(){
         synchronized (locker){
             count01++;
         }
     }
 }

运行结果符合预期值，因此没有发生线程安全问题！！

原因：两个线程会竞争locker这同一把锁

4）在多个实例中使用单独的锁对象

public class Test3{
     public static void main(String[] args) throws InterruptedException {
         //初始化累加对象
         Counter02 counter01 = new Counter02();
         Counter02 counter02 = new Counter02();
         //创建两个线程对同一个变量进行累加
         Thread t1 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter01.increase();
             }
         });
         //启动线程
         t1.start();
 ​
         Thread t2 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter02.increase();
             }
         });
         //启动线程
         t2.start();
 ​
         t1.join();
         t2.join();
         System.out.println("count02:" + Counter02.count02);
     }
 }
 ​
 class Counter02{
     public static int count02 = 0;
     //单独定义一个对象为锁对象使用
     Object locker = new Object();
     /**
      * 简单累加方法
      */
     public void increase(){
         synchronized (locker){
             count02++;
         }
     }
 }

结果不符合预期，发生线程安全问题！！！

原因：因为Couner02这个类每实例化一个对象一次，就会创建一次locker对象，所以两个线程竞争的是不同的两把锁，会发生线程安全问题

5）使用静态全局对象为锁对象

这个方法可以解决在多个实例中使用单独的锁对象

由于将locker作为静态全局对象，因此无论创建多少个实例对象，其锁对象永远全局唯一，所以多个线程会竞争同一把锁！！！

6）单个实例中，创建两个方法，使用同一个锁对象

 public class Test4 {
     public static void main(String[] args) throws InterruptedException {
         //初始化累加对象
         Counter03 counter03 = new Counter03();
         //创建两个线程对同一个变量进行累加
         Thread t1 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter03.increase1();
             }
         });
         //启动线程
         t1.start();
 ​
         Thread t2 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter03.increase2();
             }
         });
         //启动线程
         t2.start();
 ​
         t1.join();
         t2.join();
         System.out.println("count03=" + Counter03.count03);
     }
 }
 ​
 class Counter03{
     public static int count03 = 0;
     //单独定义一个对象为锁对象使用
     Object locker = new Object();
     /**
      * 简单累加方法
      */
     public void increase1(){
         synchronized (locker){
             count03++;
         }
     }
     public void increase2(){
         synchronized (locker){
             count03++;
         }
     }
 }

没有发生线程安全问题，因为locker是同一个锁对象，会进行锁对象竞争！！！

7）使用类对象作为锁对象

 public class Test5 {
 ​
     public static void main(String[] args) throws InterruptedException {
         //初始化累加对象
         Counter05 counter05 = new Counter05();
         //创建两个线程对同一个变量进行累加
         Thread t1 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter05.increase();
             }
         });
         //启动线程
         t1.start();
 ​
         Thread t2 = new Thread(()->{
             //5万次
             for (int i = 0; i < 50000; i++) {
                 counter05.increase();
             }
         });
         //启动线程
         t2.start();
 ​
         t1.join();
         t2.join();
         System.out.println("count05=" + Counter05.count05);
     }
 }
 ​
 class Counter05{
     public static int count05 = 0;
     /**
      * 简单累加方法
      */
     public void increase(){
         synchronized (Counter05.class){
             count05++;
         }
     }
 ​
 }

结果：符合预期，因为类对象是全局唯一的，所以会产生锁竞争，不发生线程安全问题

8）使用String.class作为锁对象

根据前一个例子的代码，将锁对象修改为String.class，也可以成功解除线程安全问题！！！

根据上述结果预测推断：我们使用Integer.class也可以解决线程安全问题！！！

总结：

根据上述几种方案可以推断：要使用synchronized解决线程安全问题，锁对象可以任意选择，但是一定注意一个点，那就是多个线程竞争的锁对象一定是唯一的！！！

volatile关键字

这个关键字真正解决了内存可见性

也可以解决有序性问题（禁止指令重排序）

1）解决内存可见性

为了解决内存可见性问题，关键在于一个线程修改了另一个线程需要的变量的时候，必须要让另一个线程知道

Java层面解决内存可见性

我们还是借助于JMM内存模型来看

代码在写入volatile修饰的变量的时候，

改变线程工作内存中volatile变量副本的值

将修改后的副本的值从工作内存刷新到主内存

代码在读取volatile修饰的变量的时候，

从主内存中读取volatile变量的最新值到线程的工作内存中

从工作内存中读取volatile变量的副本

注意：

虽然代码直接访问工作内存（实际上是CPU的寄存器或者CPU的缓存），速度非常快，但是可能出现数据不一致的情况

加上volatile，强制读写内存，速度是慢了，但是数据变得更准确了

内存屏障

上述讲述了JMM层面解决内存可见性的问题，但是其最底层是通过内存屏障来实现的

内存屏障的作用：保证指令执行的先后顺序，从而保证内存可见性

屏障的类型（四种）

 

注：加了volatile修饰的变量，前后都会有内存屏障，涉及到的读和写都是从主内存中读取的，因此真正实现了内存可见性问题！！！

2）解决指令重排序问题

加了volatile修饰的变量，前后都i有内存屏障，保证了指令的顺序执行

也可以理解为告诉编译器，不要进行指令重排序！！！

3）volatile不保证原子性

总结

经典例题

面试题

JMM中如何实现原子性、内存可见性、有序性？

1.synchronized实现了原子性，由于串行执行，侧面实现了内存可见性

2.volatile真正实现了内存可见性和有序性（通过内存屏障来实现！！）

3.通常volatile和synchronized结合起来使用，这样可以更好保证内存安全

以上就是关于解决线程安全的方法，主要通过volatile和synchronized两个关键字来实现，希望能够帮助到大家，大家有任何疑问，也可以随时在评论区中留言哦！

作者：顾漂亮