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

原创于 2025-01-11 16:11:32 发布 · 1.1k 阅读

49 ·

CC 4.0 BY-SA版权

文章标签：

#安全 #java #云计算 #多线程

synchronized关键字 - 监视锁 monitor lock

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

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

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

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

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

前言：

关于多线程创建和造成线程安全的原因，博主已经在前面的玩转多线程--入门-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两个关键字来实现，希望能够帮助到大家，大家有任何疑问，也可以随时在评论区中留言哦！

33 条评论

c-c-developer 2025.02.15
优质好文博主加油

阿J~ 2025.01.29
先一键三连，有空慢慢研究

半截诗 2025.01.14
文章内容丰富，涵盖了很多实用的知识点，对我来说非常有帮助。尤其是博主在文章中提供了很多实际操作的步骤和技巧，让我能够更好地应用所学的知识。非常感谢博主的分享，期待博主能够继续输出这样优质的好文。

f狐0狸x 2025.01.13
干货满满，实用性强，博主的写作风格简洁明了，让人一目了然。文章内容丰富，涵盖了很多实用的知识点。非常感谢博主的分享，期待博主能够继续输出这样优质的好文。

TANGLONG222 2025.01.11
这篇文章专业且深入，语言清晰易懂，逻辑严密，读后收获颇丰。作者见解独到，期待更多佳作！

猫咪-9527 2025.01.11
大佬大作，实属精品！博主的文章一直都是我的学习指南，内容详实，让我从中获益良多，每篇博文都是知识的瑰宝，我真的很喜欢你的风格，你的博客内容深入浅出，总是让我不再感到学习的困难，期待你的下一次精彩分享。

Microi风闲 2025.01.11
[face]emoji:062.png[/face][face]emoji:062.png[/face][face]emoji:062.png[/face]这篇文章实在是太棒了！论述清晰，代码实例更是琳琅满目，让人阅读起来津津有味。博主的专业素养和用心程度从中可见一斑，无疑为读者提供了一笔宝贵的知识财富。文章从基础概念出发，由浅入深地阐述了编程的核心思想。