关于JAVA Condition 条件变量

最新推荐文章于 2024-08-09 09:30:00 发布
最新推荐文章于 2024-08-09 09:30:00 发布
阅读量91 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/leoson/blog/106452
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

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.

 

转载于:https://my.oschina.net/leoson/blog/106452

weixin_34303897
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java并发统计变量值偏差原因及解决方案
08-19
在Java并发编程中，当多个线程同时访问并修改共享变量时，可能会出现统计值的偏差，这通常是由线程间的竞争条件（Race Condition）导致的。在给定的描述中，开发者使用了全局共享变量`CommonUtil.ReqFailNum`和`...
java多线程加锁以及Condition类的使用实例解析
08-25
Condition 类是 Java 中的一个接口，提供了条件变量机制。Condition 变量可以用来实现线程之间的通信，允许线程在某个条件下等待或通知其他线程。 在本篇文章的示例代码中，我们使用了两个 Condition 变量：notFull...
java Condition条件变量的通俗易懂解释、基本使用及注意点
weixin_34019929的博客
02-11 198
最近在看pthread方面的书，看到条件变量一节的时候，回忆了下java中条件变量的使用方式。 java中条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。...
ReentrantLock学习笔记
weixin_30847271的博客
03-14 58
参考：https://www.jianshu.com/p/4358b1466ec9 前言： 先来想象一个场景：手把手的进行锁获取和释放，先获得锁A，然后再获取锁B，当获取锁B后释放锁A同时获取锁C，当锁C获取后，再释放锁B同时获取锁D，以此类推，这种场景下，synchronized关键字就不那么容易实现了，而使用Lock却显得容易许多。 源码： public class Reentra...
Java 条件变量
Alps__的专栏
03-16 784
条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。 条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对
java 条件变量Condition——笔记
linux_lihuafeng的专栏
04-04 540
package com.warehorseCondition; public class GetThread implements Runnable{ private WareHorse horse; public GetThread(WareHorse horse) { super(); this.horse = horse; } @Override public v
java 条件变量_什么是Java中的条件变量？
weixin_30676351的博客
02-16 158
Q1。 Java中的condVar是什么？如果我看到下面的代码，条件变量是否一定必须在“ mutex.acquire() ”和“mutex.release() ”块内？public void put(Object x) throws InterruptedException {mutex.acquire();try {while (count == array.length)notFull.awa...
JavaLock与Condition的理解Reentran
11-21
Condition常用于实现条件变量，例如生产者-消费者模型、读写锁等。通过创建不同的Condition实例，可以实现不同条件下的线程通信。 六、实战技巧 1. 使用tryLock()避免死锁：在高并发环境中，可以先尝试获取锁，失败...
Java-条件词
02-15
Java中的`switch`语句提供了一种多路选择结构，通常用于基于变量的不同值执行不同的代码。基本语法如下： ```java switch (expression) { case value1: // 当expression等于value1时执行的代码 break; case ...
多线程之条件变量
05-13
在Java中，条件变量是`java.util.concurrent.locks.Condition`接口的实现，通常与锁（如`ReentrantLock`）一起使用。在C++的`std::condition_variable`库中，也有类似的实现。下面我们将深入探讨条件变量的概念、...
java 条件变量,什么是java中的条件变量？
weixin_42323064的博客
02-16 166
Q1. What is a condVar in Java? If I see the code below, does a condition variable necessarily have to be within the 'mutex.acquire()' and 'mutex.release()' block?public void put(Object x) throws Inter...
java 多线程------条件变量
dingxingmei的专栏
08-03 518
代码如下--------------- package dxm.com.test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Condition; import java.util
高效协作的秘密武器：Java线程间通信机制详解
weixin_43828090的博客
03-21 283
在多线程编程的世界里，线程间的有效通信是构建高性能、高并发系统的关键所在。Java作为主流的开发语言，提供了丰富的线程间通信机制，使得程序员能够更好地驾驭并行计算，优化程序性能。本文将深入解读Java中几种关键的线程间通信方式——wait/notify机制、条件变量Condition，以及一些高级并发工具类如CountDownLatch、Semaphore和CyclicBarrier，并结合实际应用场景进行详尽的代码解析。
java 条件变量_深入理解条件变量Condition
weixin_39896617的博客
02-19 424
序可重入锁(ReentrantLock)是 synchronized 关键字的扩展，更加灵活。还有一种ReentrantLock应用场景是和Condition搭配使用，实现多线程环境下等待状态条件的功能。Object.wait 和 Object.notify 是和 synchronized 配合使用的，条件变量Condition.await 和 Condition.signal 是和Reentra...
条件变量之虚假唤醒
shizheng163的博客
11-02 6290
如有错误请及时指正！ 文章目录条件变量之虚假唤醒引言1.什么是虚假唤醒？2.什么情况下会发生虚假唤醒3.如何避免虚假唤醒 条件变量之虚假唤醒 引言 当我们使用互斥量（Mutex）与条件变量(condition_variable)进行多线程同步时有可能会产生虚假唤醒现象, 那么究竟什么是虚假唤醒，它会在什么情况下被触发，什么情况下无需考虑虚假唤醒，如何避免？ 1.什么是虚假唤醒？ Linux帮助...
java 条件变量_关于JAVA Condition 条件变量
weixin_35988038的博客
02-16 509
Condition 条件变量条件变量是线程同步对象中的一种，主要用来等待某种条件的发生，条件发生后，可以唤醒等待在该条件上的一个线程，或所有线程。条件变量要与锁一起协同工作.条件变量调用Lock.newCondition()获得一个实例：ReentrantLock lock = new ReentrantLock();Condition condition =lock.newCondition()...
Java并发编程(11)-使用ReentrantLock与Condition实现生产者-消费者队列
程序员不鸣的博客
11-08 734
Condition在Java并发编程中是一个十分常用的接口，被称为条件变量，常与显式锁和可重入锁一起使用，它可以在某些条件下使线程进行休眠或者唤醒，本文将以实现生产者-消费者模式的队列作为demo让大家对条件变量 有初步的了解。
用Condition条件变量实现生产者消费者模式
Just Do IT
04-01 2316
import java.util.LinkedList; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class ProducerConsumerPattern{ public static final int MAX_CAP = 20;
Java面试篇（JVM相关专题）
最新发布
聂可以的博客
08-09 2754
Java面试篇（JVM相关专题）
java 多线程通信 条件变量
10-14
Java中的条件变量是通过Condition接口实现的。Condition接口提供了await()、signal()和signalAll()等方法，用于线程等待和唤醒。 当一个线程调用await()方法时，它会释放锁并进入等待状态，直到另一个线程调用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值