Java 入门指南：Java 并发编程 —— Condition 灵活管理线程间的同步

2024-09-02 01:12
文章标签 java 线程 入门 并发 管理 编程 指南 同步 灵活 condition

本文主要是介绍Java 入门指南：Java 并发编程 —— Condition 灵活管理线程间的同步，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Condition

Condition 是 Java 并发编程中的一种高级同步工具，它可以协助线程之间进行等待和通信。提供了一种比传统的 wait() 和 notify() 更加灵活的方式来管理线程间的同步。Condition 接口通常与 Lock 接口一起使用，允许更细粒度的控制线程的等待和唤醒。

每个 Condition 对象都与一个 Lock 对象相关联，它可以在等待之前获取到锁，并在等待期间自动释放锁。一旦其他线程对相关的数据做出更改并且满足某个特定条件，Condition 就可以被用来通知正在等待的线程，并进行唤醒等待的操作。

接口方法

Condition 接口提供了如下方法：

![[UML of Condition.png]]

  • await()：线程等待直到其他线程调用相同 Condition 对象的 signal/signalAll 方法，并且当前线程被唤醒；其他线程调用 interrupt 方法中断当前线程。类似于 Object.wait()。

  • await(long time, TimeUnit unit)：线程等待指定的时间，或被通知，或被中断。类似于 Object.wait(long timeout)，但提供了更灵活的时间单位。

  • awaitUninterruptibly()：线程等待直到被通知，即使在等待时被中断也不会返回，不响应中断。没有与之对应的 Object 方法。

  • awaitNanos(long nanosTimeout)：线程等待指定的纳秒时间，或被通知，或被中断，返回值小于等于0，认定为超时。没有与之对应的 Object 方法。

  • awaitUntil(Date deadline)：线程等待直到指定的截止日期，或被通知，或被中断。如果没到指定时间被通知，则返回 true，否则返回 false。没有与之对应的 Object 方法。

  • signal()：唤醒一个等待在 Condition 上的线程，被唤醒的线程在方法返回前必须获得与 Condition 对象关联的锁。类似于 Object.notify()。

  • signalAll()：唤醒所有等待在 Condition 上的线程，能够从 await()等方法返回的线程必须先获得与 Condition 对象关联的锁。类似于 Object.notifyAll()。

await()

方法逻辑：

  1. 如果当前线程被中断，抛出 InterruptedException。

  2. 通过 getState() 保存锁状态。

  3. 以保存的锁状态作为参数调用 release()，如果失败则抛出IllegalMonitorStateException。

  4. 阻塞直到被通知或线程中断。

  5. 通过以保存状态作为参数调用 acquire() 的带参方法来重新获取锁。

  6. 如果在第4步阻塞时中断，则抛出 InterruptedException。

![[Condition.await() Queue.png]]

调用 condition.await 方法的线程必须是已经获得了 lock 的线程，也就是当前线程是同步队列中的头节点。

当前线程调用condition.await() 方法后，会释放 lock 然后加入到等待队列，直到被 signal/signalAll 方法唤醒。

线程如何被添加到等待队列

在 await() 中 调用了 addConditionWaiter 方法会将当前线程添加到等待队列中。

将不处于等待状态的节点从等待队列中移除，通过尾插入的方式将当前线程封装的 Node 插入到等待队列中，同时可以看出，Condtion 的等待队列是一个不带头节点的链式队列。

释放锁的过程

将当前节点插入到等待对列之后，会使当前线程释放 lock，由 fullyRelease 方法实现

首先获取锁的状态，调用 AQS 的模板方法 release 释放 AQS 的同步状态，并且唤醒在同步队列中头节点的后继节点引用的线程，如果释放成功则正常返回，若失败，抛出 IllegalMonitorStateException，并将节点状态设置为 CANCELLED

退出 await()

退出 await 方法的前提条件是当前线程被中断或者调用 condition.signal() 或者 condition.signalAll() 使当前节点移动到同步队列后。

当退出 while 循环后会调用 acquireQueued(node, savedState)，该方法的作用是在自旋过程中线程不断尝试获取同步状态，直到成功（线程获取到 lock）。这样也说明了退出 await 方法必须是已经获得了 condition 引用（关联）的 lock。

signal()

调用 condition 的 signal() 或者 signalAll() 方法可以将等待队列中等待时间最长的节点移动到同步队列中，使得该节点能够有机会获得 lock。

signal() 方法源码
![[ConditionObject.signal().png]]
doSignal() 方法源码
![[ConditionObject.doSignal.png]]

调用 condition.signal 方法的前提条件是当前线程已经获取了 lock，若未获得 lock，会直接抛出 IllegalMonitorStateException

等待队列是先进先出（FIFO）的，所以等待队列的头节点必然会是等待时间最长的节点，也就是每次调用 condition 的 signal 方法都会将头节点的状态设置为 CONDITION，并移动到同步队列中。

![[ConditionObject.signal() Process.png]]

signalAll()

signalAll 与 signal 方法的区别体现在 doSignalAll 方法上，该方法会将等待队列中的每一个节点都移入到同步队列中，即“通知”当前调用 condition.await() 方法的每一个线程。

await() 与 signal()

await、signal 和 signalAll 方法就像一个开关，控制着线程 A（等待方）和线程 B（通知方）

![[Condition working process.png]]

  • 线程 awaitThread 先通过 lock.lock() 方法获取锁，成功后调用 condition.await 方法进入等待队列

  • 另一个线程 signalThread 通过 lock.lock() 方法获取锁成功后调用了 condition.signal 或者 signalAll 方法，使得线程 awaitThread 能够有机会移入到同步队列中.

  • 当其他线程释放 lock 后使得线程 awaitThread 能够有机会获取 lock，从而使得线程 awaitThread 能够从 await 方法中退出并执行后续操作。

  • 如果 awaitThread 获取 lock 失败会直接进入到同步队列。

创建 Condition 对象

可以通过 lock.newCondition() 来创建一个 Condition 对象，这个方法实际上会 new 一个 ConditionObject 的对象，ConditionObject 是 [[AQS、AQLS、AOS]] 的一个内部类

![[ReentrantLock newCondition.png]]

AQS 内部维护了一个 FIFO 的双端队列，Condition 内部也使用了同样的方式，内部维护了一个先进先出（FIFO）的单向队列，称为等待队列。

![[Queue of Condition.png]]

![[Condition Queue Node.png]]

用 await 方法的线程都会加入到等待队列中，并且线程状态均为等待状态。firstWaiter 指向首节点，lastWaiter 指向尾节点

Node 中的 nextWaiter 指向队列中的下一个节点。并且进入到等待队列的 Node 节点状态都会被设置为 CONDITION

如果该线程能够从 await() 方法返回的话，一定是该线程获取了与 Condition 相关联的锁。

![[AQS And Condition Queue.png]]

可以多次调用 newCondition() 方法创建多个 Condition 对象，也就是一个 lock 可以持有多个等待队列。

使用多个 Condition 对象的主要优点是为锁提供了更细粒度的控制，可以实现更复杂的同步场景。

Object.monitor 和 Condition

每个对象都可以用 Object 的 wait() 、notify() 方法来实现等待/通知机制。而 Condition 接口也提供了类似 Object 的方法 await() signal()，可以配合Lock 来实现等待/通知模式。****

![[Object.monitor Condition Comparison.png]]

相似之处

  1. 线程等待：Condition 的 await() 方法和 Object 的 wait() 方法都可以使当前线程进入等待状态，直到被其他线程唤醒。

  2. 线程唤醒：

    • Condition 的 signal() 方法和 Object 的 notify() 方法都可以唤醒一个等待的线程。
    • Condition 的 signalAll() 方法类似于 Object 的 notifyAll() 方法，可以唤醒所有等待的线程。
不同之处

  1. 锁的显式管理：

    • Condition 必须与 Lock 结合使用，这意味着开发者需要显式地管理锁的获取和释放。这使得代码结构更加清晰，可以避免一些常见的锁使用错误。
    • Object 的 wait 和 notify 方法则隐含地使用了对象的内置锁（即 synchronized 语句块或方法所持有的锁）。

  2. 多个条件变量：Condition 允许在同一把锁上创建多个条件变量，这意味着可以在一个锁对象上实现多个不同的等待条件，而 Object 的 wait/notify 方法只能在单个对象上实现单一的等待条件。

  3. 更细粒度的控制：

    • Condition 提供了更多控制选项，例如 awaitNanos、awaitUntil 等方法，可以设置等待的超时时间，这使得线程可以在指定时间内等待，而不是无限期地等待。

    • Object 的 wait 方法虽然也有超时参数，但在使用上不如 Condition 灵活。

  4. 异常处理：

    • Condition 的 await 方法在等待过程中可能会被中断，从而抛出 InterruptedException。此时，开发人员可以选择是否恢复中断状态。

    • Object 的 wait 方法同样会在线程被中断时抛出 InterruptedException，但恢复中断状态需要手动设置。

Condition 实现生产者消费者模式

下面是一个使用 Condition 实现的生产者消费者模式的例子，该模式常用于线程间的同步问题。

仓库类

首先，我们定义一个仓库类，它包含一个生产者使用的 put 方法和消费者使用的 take 方法。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Warehouse {private final int maxSize;private int size;private final Lock lock = new ReentrantLock();private final Condition notFull = lock.newCondition();private final Condition notEmpty = lock.newCondition();public Warehouse(int maxSize) {this.maxSize = maxSize;this.size = 0;}public void put(int item) throws InterruptedException {lock.lock();try {// 如果仓库已满，等待直到有空间可用while (size == maxSize) {notFull.await();}// 添加物品size++;System.out.println("Produced item: " + item);// 唤醒等待的消费者notEmpty.signal();} finally {lock.unlock();}}public int take() throws InterruptedException {lock.lock();try {// 如果仓库为空，等待直到有物品可用while (size == 0) {notEmpty.await();}// 移除物品size--;int item = ThreadLocalRandom.current().nextInt(100);System.out.println("Consumed item: " + item);// 唤醒等待的生产者notFull.signal();return item;} finally {lock.unlock();}}
}

生产者和消费者线程

接下来，我们创建生产者和消费者的线程类。

public class Producer implements Runnable {private final Warehouse warehouse;public Producer(Warehouse warehouse) {this.warehouse = warehouse;}@Overridepublic void run() {for (int i = 0; i < 10; i++) {try {warehouse.put(i);Thread.sleep(1000); // 模拟生产过程} catch (InterruptedException e) {Thread.currentThread().interrupt();System.out.println("Producer interrupted");}}}
}public class Consumer implements Runnable {private final Warehouse warehouse;public Consumer(Warehouse warehouse) {this.warehouse = warehouse;}@Overridepublic void run() {for (int i = 0; i < 10; i++) {try {warehouse.take();Thread.sleep(1500); // 模拟消费过程} catch (InterruptedException e) {Thread.currentThread().interrupt();System.out.println("Consumer interrupted");}}}
}

主函数

最后，我们在主函数中创建生产者和消费者线程，并启动它们。

public class Main {public static void main(String[] args) {Warehouse warehouse = new Warehouse(5);Thread producerThread = new Thread(new Producer(warehouse), "Producer");Thread consumerThread = new Thread(new Consumer(warehouse), "Consumer");producerThread.start();consumerThread.start();}
}

示例说明

  1. Lock 和 Condition:

    • 使用 ReentrantLock 创建一个可重入锁。
    • 通过 lock.newCondition() 创建两个 Condition 对象，分别用于控制生产者和消费者的等待条件。

  2. 生产者:

    • 在 put 方法中，当仓库已满时，生产者将等待 notFull 条件被信号唤醒。
    • 生产者添加物品后，唤醒等待的消费者。

  3. 消费者:

    • 在 take 方法中，当仓库为空时，消费者将等待 notEmpty 条件被信号唤醒。
    • 消费者移除物品后，唤醒等待的生产者。

通过这种方式，生产者和消费者之间可以很好地协同工作，避免了死锁的风险，并且提供了更灵活的线程控制手段。

这篇关于Java 入门指南：Java 并发编程 —— Condition 灵活管理线程间的同步的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1128574。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
基于MySQL Binlog的Elasticsearch数据同步实践

基于MySQL Binlog的Elasticsearch数据同步实践

一、为什么要做 随着马蜂窝的逐渐发展，我们的业务数据越来越多，单纯使用 MySQL 已经不能满足我们的数据查询需求，例如对于商品、订单等数据的多维度检索。 使用 Elasticsearch 存储业务数据可以很好的解决我们业务中的搜索需求。而数据进行异构存储后，随之而来的就是数据同步的问题。 二、现有方法及问题 对于数据同步，我们目前的解决方案是建立数据中间表。把需要检索的业务数据，统一放到一张M
阅读更多...
服务器集群同步时间手记

服务器集群同步时间手记

1.时间服务器配置（必须root用户） （1）检查ntp是否安装 [root@node1 桌面]# rpm -qa|grep ntpntp-4.2.6p5-10.el6.centos.x86_64fontpackages-filesystem-1.41-1.1.el6.noarchntpdate-4.2.6p5-10.el6.centos.x86_64 （2）修改ntp配置文件 [r
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2