深入学习并发编程中的 synchronized

tiantian17)2024-10-04 20:24

文章目录

并发编程中的三个问题

可见性

是指一个线程对共享变量进行修改，另一个先立即得到修改后的最新值

演示可见性问题：

实际效果：线程 1 并没有退出循环，说线程二修改了flag的值，而线程一并没有立即得到修改后的值。

原子性

原子性（Atomicity）：在一次或多次操作中，要么所有的操作都执行并且不会受其他因素干扰而中断，要么所有的操作都不执行。

演示原子性问题：

执行几次后的实际结果：

证明：

number++ 实际上是一个复合操作（且是非原子性的），它包含三个步骤：

  1. 读取 number 的当前值。
  2. 将读取的值加1。
  3. 将结果写回到 number。

再通过反汇编说明number++的问题：

javap -p -v .\AtomicityDemo

其中，对于number++ 而言（number 为静态变量），实际会产生如下的 JVM 字节码指令：

number++ 一共由于4条命令构成

  • getstatic：获取到当前 number 的值
  • iconst_1：准备常量 1
  • iadd：当前值与 iconst_1 做加法
  • putstatic：将结果赋值给 number

以上多条指令在一个线程的情况下是不会出问题的，但是在多线程环境下就可能会出现问题。比如一个线程在执行 13: iadd 时，另一个线程又执行 9: getstatic。会导致两次 number++，实际上只加了1。

有序性

是指程序代码在执行过程中的先后顺序，由于Java在编译期以及运行期的优化，导致了代码的执行顺序未必就是开发者编写代码时的顺序。

举个例子🌰：

java 复制代码 
int a = 1; // 操作1
int b = 2; // 操作2

// 重排序后
int b = 2; // 操作2
int a = 1; // 操作1

出现可见性问题的两个前提：至少有两个线程、有个共享变量

java 复制代码 
public class Ordering {
	private int num = 0;
	private boolean flag = false;
	private int x;
	
	public void action1() {
		if (flag) {
			x = num + num;
		} else {
			x = 1;
		}
		// x的可能结果
		System.out.println(x);
	}
	
	public void action2() {
		num = 2;
		flag = true;
	}
}

x的可能结果：

  • 结果1：线程1执行 action1()，此时 flag=false，x的结果为1
  • 结果2：线程2先执行了 action2()，线程1再执行 action1()，此时 flag=true, num=2，x的结果为4
  • 结果3：java在编译和运行时会对代码进行优化，action2()的执行顺序变成了如下，此时线程2更改flag值之后，CPU切换到线程1执行，num为初始化的值0，x的结果为0
java 复制代码 
public void action2() { // 因为第2行和第3行代码并没有逻辑关系 Java在编译期以及运行期的优化 可能会将其改变顺序
    flag = true;
    num = 2;
}

上面的结果3就是有序性产出的并发问题

了解Java内存模型JMM

Java内存模型（Java Memory Model, JMM）是Java虚拟机(JVM)定义的一种规范，用于描述多线程程序中变量（包括实例字段、静态字段和数组元素）如何在内存中存储和传递的规则。规范了线程何时会从主内存中读取数据、何时会把数据写回主内存。

JMM 抽象了线程和主内存之间的关系，就比如说线程之间的共享变量必须存储在主内存中。

JMM 的核心目标是确保多线程环境下的可见性、有序性和原子性，从而避免由于硬件和编译器优化带来的不一致问题。

  • 可见性 ：确保一个线程对变量的修改，能及时被其他线程看到。关键字 volatile 就是用来保证可见性的，它强制线程每次读写时都直接从主内存中获取最新值。
  • 有序性 ：指线程执行操作的顺序。JMM允许某些指令重排序以提高性能，但会保证线程内的操作顺序不会被破坏，并通过 happens-before 关系保证跨线程的有序性。
  • 原子性 ：是指操作不可分割，线程不会在执行过程中被中断。例如，synchronized 关键字能确保方法或代码块的原子性。

从 JMM 了解可见性：线程 1 将 a 的值拷贝一份并修改了 a 的值，然后同步给主内存的值，而线程 2 一直用的是副本的值，并不知道主内存的值已被修改了，所以线程 1 修改的值，对于线程 2 来说是不可见的。

synchronized 保证三大特性

synchronized能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。

java 复制代码 
synchronized (锁对象) {
// 受保护资源;
}

synchronized 保证原子性

synchronized保证原子性的原理，synchronized保证只有一个线程拿到锁，能够进入同步代码块。

案例演示:5个线程各执行1000次 i++;

java 复制代码 
public class Test01Atomicity {
    private static int number = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable increment = () -> {
            for (int i = 0; i < 1000; i++) {
                synchronized (Test01Atomicity.class) {
                    number++;
                }
            }
        };
        ArrayList<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 50; i++) {
            Thread t = new Thread(increment);
            t.start();
            ts.add(t);
        }
        for (Thread t : ts) {
            t.join();
        }
        System.out.println("number = " + number);
    }
}

对number++;增加同步代码块后，保证同一时间只有一个线程操number++;。就不会出现安全问题。

synchronized 保证可见性

案例演示：一个线程根据boolean类型的标记flag， while循环，另一个线程改变这个flag变量的值，另一个线程并不会停止循环。

java 复制代码 
public class Test01Visibility {
    // 多个线程都会访问的数据，我们称为线程的共享数据
    private static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (run) {
                // 增加对象共享数据的打印，println是同步方法
                System.out.println("run = " + run);
            }
        });
        t1.start();
        Thread.sleep(1000);
        Thread t2 = new Thread(() -> {
            run = false;
            System.out.println("时间到，线程2设置为false");
        });
        t2.start();
    }
}

点进去println，本质还是加了 synchronized 关键字

synchronized 保证有序性

为什么要重排序：

为了提高程序的执行效率，编辑器和cpu会对程序中的代码进行重排序

as-if-serial语义：

as-if-serial语义的意思是：不管编译器和CPU如何重排序，必须保证在单线程情况下程序的结果是正确的。 以下数据有依赖关系，不能重排序。

  • 写后读

    java 复制代码 
    int a = 1;
int b = a;

  • 写后写

    java 复制代码 
    int a = 1;
int a = 2;

  • 读后写

    java 复制代码 
    int a = 1;
int b = a;
int a = 2;

synchronized 后，虽然进行了重排序，保证只有一个线程会进入同步代码块，也能保证有序性。

synchronized 保证有序性的原理，加s ynchronized 后，依然会发生重排序，只不过，我们有同步代码块，可以保证只有一个线程执行同步代码中的代码。保证有序性。

synchronized 的特性

可重入特性

synchronized内部维护了一个计数器（ recursions 变量），记录线程是第几次获取锁，在执行完同步代码块时，计数器的数量会 - 1 ，直到计时器的数量为 0，就释放这个锁。

好处：1）可以避免死锁 2）可以让我们更好的来封装代码

不可中断特性

不可中断特性：一个线程获得锁后，另一个线程想要获得锁，必须处于阻塞或等待状态，如果第一个线程不释放锁，第二个线程会一直阻塞或等待，不可被中断。

java 复制代码 
public class Demo02_Uninterruptible {
    private static final Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        // 1.定义一个Runnable
        Runnable run = () -> {
            // 2.在Runnable定义同步代码块
            synchronized (obj) {
                String name = Thread.currentThread().getName();
                System.out.println(name + "进入同步代码块");
                // 保证不退出同步代码块
                try {
                    Thread.sleep(888888);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        // 3.先开启一个线程来执行同步代码块
        Thread t1 = new Thread(run);
        t1.start();
        Thread.sleep(1000);
        // 4.后开启一个线程来执行同步代码块(阻塞状态)
        Thread t2 = new Thread(run);
        t2.start();
        // 5.停止第二个线程
        System.out.println("停止线程前");
        t2.interrupt();
        System.out.println("停止线程后");
        System.out.println(t1.getState());
        System.out.println(t2.getState());
    }
}

执行结果：

t1 线程不释放锁，t2 线程会一直阻塞或等待，既不可被中断。

通过反汇编学习synchronized原理

它的实现原理依赖与 JVM 中的 Monitor（监视器锁）和对象头（Object Header）。

当修饰代码块时

会在代码块的前后插入monitorenter和monitorexit字节码指令，可以把monitorenter理解为加锁，monitorexit理解为解锁。

第二次出现 monitorexit 可以理解为出现异常的情况也需要解锁。

monitorenter：

  • synchronized 的锁对象会关联一个 monitor，这个 monitor 不是我们主动创建的，是 JVM 的线程执行到这个同步代码块，发现锁对象没有monitor 就会创建 monitor，monitor 内部有两个重要的成员变量owner: 拥有 这把锁的线程，recursions 会记录线程拥有锁的次数，当一个线程拥有 monitor 后其他线程只能等待。

monitorexit：

  • 能执行 monitorexit 指令的线程一定是拥有当前对象的 monitor 的所有权的线程。
  • 执行 monitorexit 时会将 monitor 的进入数减 1。当 monitor 的进入数减为 0 时，当前线程退出 monitor，不再拥有 monitor 的所有权，此时其他被这个 monitor 阻塞的线程可以尝试去获取这个 monitor的所有权。

当修饰方法时

方法的常量池会添加一个 ACC_SYNCHRONIZED 标识，当某个线程访问这个方法时会检查是否有ACC_SYNCHRONIZED标识，若有则需要获取监视器锁才可以执行方法，此时就保证了方法的同步。

通过JVM源码学习synchronized

monitor 监视器锁

在 HotSpot 虚拟机中 monitor 是通过 ObjectMonitor 实现的，底层是 c++ 实现的，其数据结构和解释如下：

monitor竞争

  1. 通过CAS尝试把 monitor 的 owner 字段设置为当前线程。
  2. 如果设置之前的 owner 指向当前线程，说明当前线程再次进入monitor，即重入锁，执行 recursions ++ ，记录重入的次数。
  3. 如果当前线程是第一次进入该 monitor，设置 recursions 为 1，_owner 为当前线程，该线程成功获 得锁并返回。
  4. 如果获取锁失败，则等待锁的释放。

monitor等待

  1. 当前线程被封装成ObjectWaiter对象node，状态设置成ObjectWaiter::TS_CXQ。
  2. 在for循环中，通过 CAS 把 node 节点 push 到 _cxq 列表中，同一时刻可能有多个线程把自己的 node 节点 push 到_cxq列表中。
  3. node节点push到_cxq列表之后，通过自旋尝试获取锁，如果还是没有获取到锁，则通过park将当 前线程挂起，等待被唤醒。
  4. 当该线程被唤醒时，会从挂起的点继续执行，通过ObjectMonitor::TryLock 尝试获取锁。

monitor释放

当某个持有锁的线程执行完同步代码块时，会进行锁的释放，给其它线程机会执行同步代码，在 HotSpot中，通过退出monitor的方式实现锁的释放，并通知被阻塞的线程。

  1. 退出同步代码块时会让_recursions 减 1，当 recursions 的值减为0时，说明线程释放了锁。
  2. 根据不同的策略（由QMode指定），从cxq或EntryList中获取头节点，通过 ObjectMonitor::ExitEpilog 方法唤醒该节点封装的线程，唤醒操作最终由unpark完成。
相关推荐
BestandW1shEs2 分钟前
彻底理解消息队列的作用及如何选择
java·kafka·rabbitmq·rocketmq
爱吃烤鸡翅的酸菜鱼4 分钟前
Java算法OJ（8）随机选择算法
java·数据结构·算法·排序算法
码蜂窝编程官方8 分钟前
【含开题报告+文档+PPT+源码】基于SpringBoot+Vue的虎鲸旅游攻略网的设计与实现
java·vue.js·spring boot·后端·spring·旅游
Viktor_Ye24 分钟前
高效集成易快报与金蝶应付单的方案
java·前端·数据库
hummhumm26 分钟前
第 25 章 - Golang 项目结构
java·开发语言·前端·后端·python·elasticsearch·golang
一二小选手30 分钟前
【Maven】IDEA创建Maven项目 Maven配置
java·maven
J老熊36 分钟前
JavaFX：简介、使用场景、常见问题及对比其他框架分析
java·开发语言·后端·面试·系统架构·软件工程
猿java41 分钟前
什么是 Hystrix？它的工作原理是什么？
java·微服务·面试
AuroraI'ncoding42 分钟前
时间请求参数、响应
java·后端·spring
zmd-zk1 小时前
flink学习（2）——wordcount案例
大数据·开发语言·学习·flink
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿