关键词搜索

源码搜索 ×
×

JAVA线程间协作：Condition

发布2016-01-01浏览6100次

详情内容

欢迎支持笔者新作：《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客。

欢迎跳转到本文的原文链接：https://honeypps.com/java/java-multi-thread-of-condition/

    内置条件队列存在一些缺陷。每个内置锁都只能有一个相关联的条件队列，因而在像BounderBuffer这种类中，多个线程可能在同一个条件队列上等待不同的条件谓词，并且在最常见的加锁模式下公开条件队列对象。这些因素都使得无法满足在使用notifyAll时所有等待线程为统一类型的需求。如果想编写一个带有多个条件谓词的并发对象，或者想获得除了条件队列可见性之外的更多控制权，就可以使用显示的Lock和Condition而不是内置锁和条件队列，这是一种更灵活的选择。

    一个Condition和一个Lock关联在一起，就想一个条件队列和一个内置锁相关联一样。要创建一个Condition，可以在相关联的Lock上调用Lock.newCondition方法。正如Lock比内置加锁提供了更为丰富的功能，Condition同样比内置条件队列提供了更丰富的功能：在每个锁上可存在多个等待、条件等待可以是可中断的或者不可中断的、基于时限的等待，以及公平的或非公平的队列操作。

    与内置条件队列不同的是，对于每个Lock，可以有任意数量的Condition对象。Condition对象继承了相关的Lock对象的公平性，对于公平的锁，线程会依照FIFO顺序从Condition.await中释放。

Condition接口：

 

  1. public interface Condition{
  2.     void await() throws InterruptedException;
  3.     boolean await(long time, TimeUnit unit) throws InterruptedException;
  4.     long awaitNanos(long nanosTimeout) throws InterruptedException;
  5.     void awaitUniterruptibly();
  6.     boolean awaitUntil(Date deadline) throws InterruptedException;
  7.     void signal();
  8.     void signalAll();
  9. }

    注意：在Condition对象中，与wait,notify和notifyAll方法对于的分别是await,signal,signalAll。但是，Condition对Object进行了扩展，因而它也包含wait和notify方法。一定要确保使用的版本——await和signal.
官方使用方法如下：

  1. class BoundedBuffer
  2. {
  3.     final Lock lock = new ReentrantLock();
  4.     final Condition notFull = lock.newCondition();
  5.     final Condition notEmpty = lock.newCondition();
  6.  
  7.     final Object[] items = new Object[100];
  8.     int putptr, takeptr, count;
  9.  
  10.     public void put(Object x) throws InterruptedException
  11.     {
  12.         lock.lock();
  13.         try
  14.         {
  15.             while (count == items.length)
  16.                 notFull.await();
  17.             items[putptr] = x;
  18.             if (++putptr == items.length)
  19.                 putptr = 0;
  20.             ++count;
  21.             notEmpty.signal();
  22.         }
  23.         finally
  24.         {
  25.             lock.unlock();
  26.         }
  27.     }
  28.  
  29.     public Object take() throws InterruptedException
  30.     {
  31.         lock.lock();
  32.         try
  33.         {
  34.             while (count == 0)
  35.                 notEmpty.await();
  36.             Object x = items[takeptr];
  37.             if (++takeptr == items.length)
  38.                 takeptr = 0;
  39.             --count;
  40.             notFull.signal();
  41.             return x;
  42.         }
  43.         finally
  44.         {
  45.             lock.unlock();
  46.         }
  47.     }
  48. }

    或者通过一个实际的例子来解释Condition的用法：
    我们要打印1-9这0个数字，由A线程先打印1-3，然后由B线程打印4-6，然后再由A线程打印7-9.我们采用Condition来演示解决方法：

  1. package com.cooperation;
  2.  
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  6.  
  7. public class TestCondition
  8. {
  9.     private static int value = 1;
  10.     private Lock lock = new ReentrantLock();
  11.     private Condition Condition456 = lock.newCondition();
  12.     private Condition Condition789 = lock.newCondition();
  13.  
  14.     class ThreadA implements Runnable{
  15.         @Override
  16.         public void run()
  17.         {
  18.             try
  19.             {
  20.                 lock.lock();
  21.                 System.out.println("首先输出1-3");
  22.                 while(value<=3)
  23.                 {
  24.                     System.out.println(value++);
  25.                 }
  26.                 Condition456.signal();
  27.             }
  28.             finally
  29.             {
  30.                 lock.unlock();
  31.             }
  32.  
  33.             try
  34.             {
  35.                 lock.lock();
  36.                 while(value<=6)
  37.                 {
  38.                     Condition789.await();
  39.                 }
  40.                 System.out.println("输出7-9");
  41.                 while(value<=9)
  42.                 {
  43.                     System.out.println(value++);
  44.                 }
  45.             }
  46.             catch (InterruptedException e)
  47.             {
  48.                 e.printStackTrace();
  49.             }
  50.             finally
  51.             {
  52.                 lock.unlock();
  53.             }
  54.  
  55.         }
  56.     }
  57.  
  58.     class ThreadB implements Runnable{
  59.         @Override
  60.         public void run()
  61.         {
  62.             try
  63.             {
  64.                 lock.lock();
  65.                 while(value<=3)
  66.                 {
  67.                     Condition456.await();
  68.                 }
  69.             }
  70.             catch (InterruptedException e)
  71.             {
  72.                 e.printStackTrace();
  73.             }
  74.             finally{
  75.                 lock.unlock();
  76.             }
  77.  
  78.             try{
  79.                 lock.lock();
  80.                 System.out.println("输出4-6");
  81.                 while(value<=6)
  82.                 {
  83.                     System.out.println(value++);
  84.                 }
  85.                 Condition789.signal();
  86.             }
  87.             finally
  88.             {
  89.                 lock.unlock();
  90.             }
  91.         }
  92.     }
  93.  
  94.     public static void main(String[] args)
  95.     {
  96.         TestCondition test = new TestCondition();
  97.         Thread threadA = new Thread(test.new ThreadA());
  98.         Thread threadB = new Thread(test.new ThreadB());
  99.         threadA.start();
  100.         threadB.start();
  101.     }
  102.  
  103. }

输出结果：

 

 

首先输出1-3
1
2
3
输出4-6
4
5
6
输出7-9
7
8
9

    如果需要采用Object方法的wait,notify,notifyAll方法实现这个实例可以参考：http://outofmemory.cn/java/java.util.concurrent/thread-sync-with-object-wait-notify-notifyAll
    同样可以扩张，ThreadA打印123，ThreadB打印456，再让ThreadA打印789，最后然ThreadB打印10 11 12.如下：

  1. package com.cooperation;
  2.  
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  6.  
  7. public class TestCondition
  8. {
  9.     private static int value = 1;
  10.     private Lock lock = new ReentrantLock();
  11.     private Condition Condition456 = lock.newCondition();
  12.     private Condition Condition789 = lock.newCondition();
  13.     private Condition Condition101112 = lock.newCondition();
  14.  
  15.     class ThreadA implements Runnable{
  16.         @Override
  17.         public void run()
  18.         {
  19.             try
  20.             {
  21.                 lock.lock();
  22.                 System.out.println("首先输出1-3");
  23.                 while(value<=3)
  24.                 {
  25.                     System.out.println(value++);
  26.                 }
  27.                 Condition456.signal();
  28.             }
  29.             finally
  30.             {
  31.                 lock.unlock();
  32.             }
  33.  
  34.             try
  35.             {
  36.                 lock.lock();
  37.                 while(value<=6)
  38.                 {
  39.                     Condition789.await();
  40.                 }
  41.                 System.out.println("输出7-9");
  42.                 while(value<=9)
  43.                 {
  44.                     System.out.println(value++);
  45.                 }
  46.                 Condition101112.signal();
  47.             }
  48.             catch (InterruptedException e)
  49.             {
  50.                 e.printStackTrace();
  51.             }
  52.             finally
  53.             {
  54.                 lock.unlock();
  55.             }
  56.  
  57.         }
  58.     }
  59.  
  60.     class ThreadB implements Runnable{
  61.         @Override
  62.         public void run()
  63.         {
  64.             try
  65.             {
  66.                 lock.lock();
  67.                 while(value<=3)
  68.                 {
  69.                     Condition456.await();
  70.                 }
  71.             }
  72.             catch (InterruptedException e)
  73.             {
  74.                 e.printStackTrace();
  75.             }
  76.             finally{
  77.                 lock.unlock();
  78.             }
  79.  
  80.             try{
  81.                 lock.lock();
  82.                 System.out.println("输出4-6");
  83.                 while(value<=6)
  84.                 {
  85.                     System.out.println(value++);
  86.                 }
  87.                 Condition789.signal();
  88.             }
  89.             finally
  90.             {
  91.                 lock.unlock();
  92.             }
  93.  
  94.             try
  95.             {
  96.                 lock.lock();
  97.                 while(value<=9)
  98.                 {
  99.                     Condition101112.await();
  100.                 }
  101.             }
  102.             catch (InterruptedException e)
  103.             {
  104.                 e.printStackTrace();
  105.             }
  106.             finally{
  107.                 lock.unlock();
  108.             }
  109.  
  110.             try{
  111.                 lock.lock();
  112.                 System.out.println("输出10-12");
  113.                 while(value<=12)
  114.                 {
  115.                     System.out.println(value++);
  116.                 }
  117.             }
  118.             finally
  119.             {
  120.                 lock.unlock();
  121.             }
  122.         }
  123.     }
  124.  
  125.     public static void main(String[] args)
  126.     {
  127.         TestCondition test = new TestCondition();
  128.         Thread threadA = new Thread(test.new ThreadA());
  129.         Thread threadB = new Thread(test.new ThreadB());
  130.         threadA.start();
  131.         threadB.start();
  132.     }
  133. }

输出结果：

 

 

首先输出1-3
1
2
3
输出4-6
4
5
6
输出7-9
7
8
9
输出10-12
10
11
12

欢迎跳转到本文的原文链接：https://honeypps.com/java/java-multi-thread-of-condition/

 

欢迎支持笔者新作：《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客。

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载