注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

_

_

 
 
 

日志

 
 

关于JAVA Condition 条件变量  

2011-07-14 20:38:17|  分类: VC C++ MFC JAVA |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

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.

  评论这张
 
阅读(2645)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017