java 条件变量_关于JAVA Condition 条件变量

最新推荐文章于 2023-07-15 05:45:00 发布
最新推荐文章于 2023-07-15 05:45:00 发布
阅读量495 收藏
点赞数
文章标签： java 条件变量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35988038/article/details/114179431
版权

Condition 条件变量

条件变量是线程同步对象中的一种，主要用来等待某种条件的发生，条件发生后，可以唤醒等待在该条件上的一个线程，或所有线程。条件变量要与锁一起协同工作.

条件变量调用Lock.newCondition()获得一个实例：

ReentrantLock lock = new ReentrantLock();

Condition condition =

lock.newCondition();

通常的调用方式如下：

// 当条件 con == true 时等待

lock.lock();

try {

if (con == true) {

condition.await();

}

// do something

} finally {

lock.unlock();

}

// 条件变量的唤醒：

condition.signal(); //唤醒等待的其中一个线程

condition.signalAll(); //唤醒等待的所有线程

条件变量类似JDK1.4或以前版本中的 Object.wait(); Object.notify(); Object.notifyAll();

值得注意的是当condition.await()时，隐式的将条件变量关联的Lock解锁，而使其他线程有机会获得Lock，而检查条件，并在条件满足时，等待在条件变量上。

我们先来看一下没有条件变量时，传统的处理方式：

下面这个例子，创建3个等候线程，每个线程循环调用event.wait(),

等到了event后，显示相应的信息。

然后创建1个通知线程，每隔1秒调用 event.notify() 通知等待线程。

import java.util.Calendar;

public class TestWait {

// 创建event Object，以使用它的wait(), notify()等方法

private Object event = null;

public TestWait() {

// 创建event

event = new Object();

}

public static void main(String[] args) {

TestWait tester = new TestWait();

tester.test();

}

public Object getEvent() {

return event;

}

public void test() {

// 启动3个等候线程

new Thread(new WaitThread(this)).start();

new Thread(new WaitThread(this)).start();

new Thread(new WaitThread(this)).start();

// 启动通知线程

new Thread(new NotifyThread(this)).start();

}

}

class WaitThread implements Runnable {

private TestWait tester = null;

public WaitThread(TestWait tester) {

this.tester = tester;

}

public void run() {

Calendar now = Calendar.getInstance();

System.out.println(now.getTime() + " W " + Thread.currentThread() + " wait for event.");

while (true) {

try {

// 同步访问 event

synchronized (tester.getEvent()) {

// 等待在 event 上

tester.getEvent().wait();

}

// 等到 event 后，显示信息 "got event"

Calendar now1 = Calendar.getInstance();

System.out.println(now1.getTime() + " W " + Thread.currentThread() + " got event.");

// do something ...

Thread.sleep(500);

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

class NotifyThread implements Runnable {

private TestWait tester = null;

public NotifyThread(TestWait tester) {

this.tester = tester;

}

public void run() {

while (true) {

try {

// 间隔1秒

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

// 同步访问 event

synchronized (tester.getEvent()) {

// 通知等在event上的一个线程

tester.getEvent().notify();

// 通知等在event上的所有线程

// tester.getEvent().notifyAll();

// 打印 "fire event" 信息。

Calendar now = Calendar.getInstance();

System.out.println(now.getTime() + " N " + Thread.currentThread() + " fire event.");

}

}

}

}

程序运行结果如下：

Tue Jan 24 14:42:31 CST 2006 W Thread[Thread-0,5,main] wait for

event.

Tue Jan 24 14:42:31 CST 2006 W Thread[Thread-2,5,main] wait for

event.

Tue Jan 24 14:42:31 CST 2006 W Thread[Thread-1,5,main] wait for

event.

Tue Jan 24 14:42:31 CST 2006 N Thread[Thread-3,5,main] fire event.

Tue Jan 24 14:42:31 CST 2006 W Thread[Thread-0,5,main] got event.

Tue

Jan 24 14:42:32 CST 2006 N Thread[Thread-3,5,main] fire event.

Tue Jan 24

14:42:32 CST 2006 W Thread[Thread-2,5,main] got event.

Tue Jan 24 14:42:33

CST 2006 N Thread[Thread-3,5,main] fire event.

Tue Jan 24 14:42:33 CST 2006

W Thread[Thread-1,5,main] got event.

Tue Jan 24 14:42:34 CST 2006 N

Thread[Thread-3,5,main] fire event.

Tue Jan 24 14:42:34 CST 2006 W

Thread[Thread-0,5,main] got event.

Tue Jan 24 14:42:36 CST 2006 N

Thread[Thread-3,5,main] fire event.

Tue Jan 24 14:42:36 CST 2006 W

Thread[Thread-2,5,main] got event.

前三行启动3个等候线程，线程阻塞在 event.wait()上。

第四行通知线程Thread-3，调用event.notify();

第五行Thread-0线程，got event.

一秒钟后，Thread-3,又触发了event.notify();

下面将NotifyThread中的 event.notify();

改为event.notifyAll(); 看一下运行结果：

Tue Jan 24 15:25:43 CST 2006 W

Thread[Thread-1,5,main] wait for event.

Tue Jan 24 15:25:43 CST 2006 W

Thread[Thread-2,5,main] wait for event.

Tue Jan 24 15:25:43 CST 2006 W

Thread[Thread-0,5,main] wait for event.

Tue Jan 24 15:25:44 CST 2006 N

Thread[Thread-3,5,main] fire event.

Tue Jan 24 15:25:44 CST 2006 W

Thread[Thread-1,5,main] got event.

Tue Jan 24 15:25:44 CST 2006 W

Thread[Thread-0,5,main] got event.

Tue Jan 24 15:25:44 CST 2006 W

Thread[Thread-2,5,main] got event.

Tue Jan 24 15:25:45 CST 2006 N

Thread[Thread-3,5,main] fire event.

Tue Jan 24 15:25:45 CST 2006 W

Thread[Thread-0,5,main] got event.

Tue Jan 24 15:25:45 CST 2006 W

Thread[Thread-1,5,main] got event.

Tue Jan 24 15:25:45 CST 2006 W

Thread[Thread-2,5,main] got event.

Tue Jan 24 15:25:46 CST 2006 N

Thread[Thread-3,5,main] fire event.

Tue Jan 24 15:25:46 CST 2006 W

Thread[Thread-1,5,main] got event.

Tue Jan 24 15:25:46 CST 2006 W

Thread[Thread-0,5,main] got event.

Tue Jan 24 15:25:46 CST 2006 W

Thread[Thread-2,5,main] got event.

可以看到当Thread-3,event.notifyAll(); 所有的线程都

got event.

接下来，我们将这个例子改写为使用条件变量的例子：

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

public class TestCondition {

private ReentrantLock lock = null;

private Condition condition = null;

public TestCondition() {

lock = new ReentrantLock();

condition = lock.newCondition();

}

public static void main(String[] args) {

TestCondition tester = new TestCondition();

tester.test();

}

public void test() {

new Thread(new WaitThread1(this)).start();

new Thread(new WaitThread1(this)).start();

new Thread(new WaitThread1(this)).start();

new Thread(new NotifyThread1(this)).start();

}

public ReentrantLock getLock() {

return lock;

}

public Condition getCondition() {

return condition;

}

}

class NotifyThread1 implements Runnable {

private TestCondition tester = null;

public NotifyThread1(TestCondition tester) {

this.tester = tester;

}

public void run() {

while (true) {

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

tester.getLock().lock();

tester.getCondition().signal();

System.out.println(Thread.currentThread() + " condition signal.");

tester.getLock().unlock();

}

}

}

class WaitThread1 implements Runnable {

private TestCondition tester = null;

public WaitThread1(TestCondition tester) {

this.tester = tester;

}

public void run() {

System.out.println(Thread.currentThread() + " started.");

while (true) {

tester.getLock().lock();

try {

// getCondition().await() 将使getLock()解锁，以便其他线程可以进入 await();

tester.getCondition().await();

System.out.println(Thread.currentThread() + " get condition.");

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

tester.getLock().unlock();

}

}

}

} 运行结果如下：

Thread[Thread-0,5,main] started.

Thread[Thread-1,5,main] started.

Thread[Thread-2,5,main] started.

Thread[Thread-3,5,main] condition

signal.

Thread[Thread-0,5,main] get condition.

Thread[Thread-3,5,main]

condition signal.

Thread[Thread-1,5,main] get condition.

Thread[Thread-3,5,main] condition signal.

Thread[Thread-2,5,main] get

condition.

Thread[Thread-3,5,main] condition signal.

Thread[Thread-0,5,main] get condition.

咯嗯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java并发——条件变量
JustKian的博客
12-25 1140
1.定义 在操作系统——多线程同步互斥一文中已详细介绍过了条件变量及其使用注意事项。条件变量，是为了解决等待同步需求，实现线程间协作通信的一种机制。条件变量用来自动阻塞一个线程，直到某特殊情况发生唤醒该线程为止。通常条件变量和锁机制同时使用。 2.Java中的条件变量 2.1 synchronized + wait()、notify()、notifyAll() 线程A（消费者）: synchron...
java 条件变量_java Condition条件变量的通俗易懂解释、基本使用及注意点
weixin_33900916的博客
02-16 356
最近在看pthread方面的书，看到条件变量一节的时候，回忆了下java中条件变量的使用方式。java中条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。条...
java 条件变量_深入理解条件变量Condition
weixin_39896617的博客
02-19 410
序可重入锁(ReentrantLock)是 synchronized 关键字的扩展，更加灵活。还有一种ReentrantLock应用场景是和Condition搭配使用，实现多线程环境下等待状态条件的功能。Object.wait 和 Object.notify 是和 synchronized 配合使用的，条件变量Condition.await 和 Condition.signal 是和Reentra...
什么是条件变量？如何使用条件变量进行线程同步？什么是线程的守护线程？如何创建守护线程？
luoluoal的博客
07-15 399
条件变量是一种用于线程同步的机制，它允许一个或多个线程等待某个特定条件的发生。在使用条件变量进行线程同步时，通常需要配合互斥锁一起使用。下面是使用条件变量进行线程同步的一般步骤：初始化条件变量和互斥锁：首先需要创建一个条件变量和一个互斥锁，分别通过pthread_cond_init和pthread_mutex_init函数进行初始化。加锁：在访问共享资源之前，需要先获取互斥锁，可以使用pthread_mutex_lock函数。检查条件：在获取了互斥锁之后，需要检查条件是否满足。
Java 条件变量
Alps__的专栏
03-16 772
条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。 条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对
Java并发统计变量值偏差原因及解决方案
08-19
在Java并发编程中，当多个线程同时访问并修改共享变量时，可能会出现统计值的偏差，这通常是由线程间的竞争条件（Race Condition）导致的。在给定的描述中，开发者使用了全局共享变量`CommonUtil.ReqFailNum`和`...
java多线程加锁以及Condition类的使用实例解析
08-25
Condition 类是 Java 中的一个接口，提供了条件变量机制。Condition 变量可以用来实现线程之间的通信，允许线程在某个条件下等待或通知其他线程。 在本篇文章的示例代码中，我们使用了两个 Condition 变量：notFull...
Java_09 多线程1
08-03
为了解决这些问题，Java提供了多种同步机制，如`synchronized`块、`synchronized`方法、`java.util.concurrent`包中的锁（如`ReentrantLock`）和条件变量（如`Condition`）等。 最后，后台线程（也称为守护线程）是...
Java使用条件语句和循环结构确定控制流(实例)
08-30
Java使用条件语句和循环结构确定控制流 Java作为一门强大的编程语言，使用条件语句和循环结构是确定控制流的重要手段。本文将详细讲解Java中条件语句和循环结构的使用，包括块作用域、条件语句、循环语句和确定循环...
Java并发系列之AbstractQueuedSynchronizer源码分析（条件队列）
08-27
在Java并发编程中，`AbstractQueuedSynchronizer`(AQS)是一个重要的抽象类，用于构建锁和其他同步组件。AQS的核心是通过一个整型变量`state`来表示同步状态，并利用双端队列（FIFO）管理等待的线程。在本篇中，我们...
java线程条件变量_Java线程：条件变量、原子量、线程池等
weixin_35959694的博客
02-26 320
一、条件变量条件变量实现了java.util.concurrent.locks.Condition接口，条件变量的实例化就是通过一个Lock对象上调用newCondition()方法获得的，这样条件就和一个锁绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。条件变量的出现是为了更精细的控制线程等待与唤醒，一个锁可以有多个条件，每个条件上有多个线程等待，通过a...
java 条件变量_java多线程技术之条件变量
weixin_35554273的博客
02-16 64
上一篇讲述了并发包下的Lock，Lock可以更好的解决线程同步问题，使之更面向对象，并且ReadWriteLock在处理同步时更强大，那么同样，线程间仅仅互斥是不够的，还需要通信，本篇的内容是基于上篇之上，使用Lock如何处理线程通信。那么引入本篇的主角，Condition，Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象，以便...
Java中的Condition详解
向上的"狼"的博客
04-29 1万+
一、Condition简介 任意一个Java对象，都拥有一组监视器方法（定义在Object类中），主要包括wait，notify，notifyAll方法，这些方法与synchornized关键字相配合，可以实现等待/通知模式。 Condition接口也提供了类似的Object的监视器方法，与Lock配合可以实现等待/通知模式。但是这两者在使用方式以及功能上还是有差别的。 Condition定义了等待/通知两种类型的方法，当前线程调用这些方法时，需要提前获取到Condition对象关联的锁。Co
java线程条件变量_使用条件变量（多线程笔记）
weixin_39760967的博客
02-26 238
条件变量属性：使用条件变量可以以原子方式阻塞线程，知道某个特定条件为真为止。条件变量始终与互斥锁一起使用。使用条件变量，线程可以以原子方式阻塞，知道满足某个条件为止。对掉件的测试时在互斥锁的保护下进行的。如果条件为假，县城通常会给予条件变量则阻塞，并于原子方式释放等待条件变化的互斥锁。如果一个线程更改了条件，该线程可能会向相关的条件变量发出信号，从而是一个或多个等待的线程执行以下操作：唤醒再次获取...
java线程条件变量_Java线程：条件变量 lock
weixin_29368453的博客
02-19 215
条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。这里的条件和普通意义上的条件表达式有着天壤之别。条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()...
Java线程-线程池-条件变量
brimen的博客
03-12 757
条件变量是Java5线程当中很重要的一个概念，顾名思义，条件变量就是条件当中的一种变量，这里的条件没有实际意义，仅仅是个标记而已。 条件变量都实现了java.util.concurrent.locks.Condition接口，条件对象的实例化是通过一个lock对象上调用newCondition()方法来获取的，这样条件就和一个锁对象绑定起来，Java当中的条件变量只能和锁配合使用，来控制并发程序访...
Java多线程探究-Lock对象锁条件变量
行人事，知天命
04-12 3270
Lock锁的条件变量 设想这样的一种情况，现在有一个盘子，一个线程负责往盘子里放一个苹果，一个线程从盘子取一个苹果，如何保证线程A放一个苹果，线程B就把这个苹果取了，不会出现已经放了好几个了，线程B才一个一个的取，现在限定一个条件，盘子里每次只能放一个苹果，由于两个线程随机执行，不能保证线程A刚放了苹果，线程B就刚好取了。如果用通用的思想的话怎么做呢 应该是加条件判断，线程A每次放的时候，判断盘
【Java并发编程】之二十：并发新特性—Lock锁和条件变量（含代码）
热门推荐
兰亭风雨的专栏
12-24 2万+
本文详细讲述了显示Lock锁的各项机制：可中断锁、公平锁、读锁、写锁、条件变量实现线程间协作、await、signal、signalAll。 Java 5中引入了新的锁机制——java.util.concurrent.locks中的显式的互斥锁：Lock接口，它提供了比synchronized更加广泛的锁定操作。Lock接口有3个实现它的类：ReentrantLock、ReetrantReadWriteLock.ReadLock和ReetrantReadWriteLock.WriteLock，即重入锁
java 条件变量Condition——笔记
linux_lihuafeng的专栏
04-04 535
package com.warehorseCondition; public class GetThread implements Runnable{ private WareHorse horse; public GetThread(WareHorse horse) { super(); this.horse = horse; } @Override public v
java 多线程通信 条件变量
最新发布
10-14
Java中的条件变量是通过Condition接口实现的。Condition接口提供了await()、signal()和signalAll()等方法，用于线程等待和唤醒。 当一个线程调用await()方法时，它会释放锁并进入等待状态，直到另一个线程调用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值