22.线程通信Condition

Condition

    通过此对象可以与lock实现组合使用，为每个对象提供多个等待，实现多个阻塞队列。
  1. package dmeo9;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  6. public class DemoLock2 {
  8.     private Lock lock = new ReentrantLock();
  9.     private Condition condition1 = lock.newCondition();
  11.     public  void  m1(){
  12.         try {
  13.             lock.lock();
  14.             System.err.println(Thread.currentThread().getName()+"：线程，进入m1");
  15.             Thread.sleep(3000);
  16.             System.err.println(Thread.currentThread().getName()+"：线程，释放锁，接收通唤醒知");
  17.             condition1.await();
  18.             System.err.println(Thread.currentThread().getName()+"：线程，继续执行 m1");
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }finally {
  22.             lock.unlock();
  23.         }
  24.     }
  26.     public  void  m2(){
  27.         try {
  28.             lock.lock();
  29.             System.err.println(Thread.currentThread().getName()+"：线程，进入m2");
  30.             Thread.sleep(3000);
  31.             System.err.println(Thread.currentThread().getName()+"：线程，发出通知,唤醒");
  32.             condition1.signal();
  33.             System.err.println(Thread.currentThread().getName()+"：线程，继续执行 m2");
  34.         } catch (InterruptedException e) {
  35.             e.printStackTrace();
  36.         }finally {
  37.             lock.unlock();
  38.         }
  39.     }
  40.     public static  void main(String[] atgs) {
  41.         final DemoLock2 demoLock = new DemoLock2();
  42.         Thread t1 = new Thread(new Runnable() {
  43.             @Override
  44.             public void run() {
  45.                 demoLock.m1();;
  46.             }
  47.         },"消费者t1");
  48.         Thread t2 = new Thread(new Runnable() {
  49.             @Override
  50.             public void run() {
  51.                 demoLock.m2();;
  52.             }
  53.         },"生产者t2");
  54.         t1.start();
  55.         t2.start();
  56.     }
  57. }
  58. 输出：
  59. 消费者t1：线程，进入m1
消费者t1：线程，释放锁，接收通唤醒知
生产者t2：线程，进入m2
生产者t2：线程，发出通知,唤醒
生产者t2：线程，继续执行 m2
消费者t1：线程，继续执行 m1
多Condition组合
  1. package dmeo9;
  3. import java.util.concurrent.locks.Condition;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. /**
  8.  * Created by liudan on 2017/8/4.
  9.  */
  10. public class DemoLock3 {
  13.     /**
  14.      * 通过一对象产生lock对象，并生产多个Condition进行多线程的交互，可以做到一部分唤醒，另一部分继续等待。
  15.      */
  16.     private Lock lock = new ReentrantLock();
  17.     private Condition condition1 = lock.newCondition();
  18.     private Condition condition2 = lock.newCondition();
  20.     public void m1() {
  21.         try {
  22.             lock.lock();
  23.             System.err.println(Thread.currentThread().getName() + "：进入m1");
  24.             Thread.sleep(100);
  25.             System.err.println(Thread.currentThread().getName() + "：m1释放锁，接收通唤醒知");
  26.             condition1.await();
  27.             System.err.println(Thread.currentThread().getName() + "：继续执行 m1");
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         } finally {
  31.             lock.unlock();
  32.         }
  33.     }
  35.     public void m2() {
  36.         try {
  37.             lock.lock();
  38.             System.err.println(Thread.currentThread().getName() + "：进入m2");
  39.             Thread.sleep(200);
  40.             System.err.println(Thread.currentThread().getName() + "：m2释放锁，接收通唤醒知");
  41.             condition1.await();
  42.             System.err.println(Thread.currentThread().getName() + "：继续执行 m2");
  43.         } catch (InterruptedException e) {
  44.             e.printStackTrace();
  45.         } finally {
  46.             lock.unlock();
  47.         }
  48.     }
  50.     public void m3() {
  51.         try {
  52.             lock.lock();
  53.             System.err.println(Thread.currentThread().getName() + "：进入m3");
  54.             Thread.sleep(300);
  55.             System.err.println(Thread.currentThread().getName() + "：m3释放锁，接收通唤醒知");
  56.             condition2.await();
  57.             System.err.println(Thread.currentThread().getName() + "：继续执行 m3");
  58.         } catch (InterruptedException e) {
  59.             e.printStackTrace();
  60.         } finally {
  61.             lock.unlock();
  62.         }
  63.     }
  65.     public void m4() {
  66.         try {
  67.             lock.lock();
  68.             System.err.println(Thread.currentThread().getName() + "：进入m4");
  69.             Thread.sleep(400);
  70.             System.err.println(Thread.currentThread().getName() + "：m4发出通知并唤醒：m1、m2");
  71.             condition1.signalAll();
  72.         } catch (InterruptedException e) {
  73.             e.printStackTrace();
  74.         } finally {
  75.             lock.unlock();
  76.         }
  77.     }
  79.     public void m5() {
  80.         try {
  81.             lock.lock();
  82.             System.err.println(Thread.currentThread().getName() + "：进入m5");
  83.             Thread.sleep(500);
  84.             System.err.println(Thread.currentThread().getName() + "：m5发出通知并唤醒：m3");
  85.             condition2.signal();
  86.         } catch (InterruptedException e) {
  87.             e.printStackTrace();
  88.         } finally {
  89.             lock.unlock();
  90.         }
  91.     }
  93.     public static void main(String[] atgs) {
  94.         DemoLock3 demoLock3 = new DemoLock3();
  95.         Thread t1 = new Thread(new Runnable() {
  96.             @Override
  97.             public void run() {
  98.                 demoLock3.m1();
  99.             }
  100.         }, "_1");
  101.         Thread t2 = new Thread(new Runnable() {
  102.             @Override
  103.             public void run() {
  104.                 demoLock3.m2();
  105.             }
  106.         }, "_2");
  107.         Thread t3 = new Thread(new Runnable() {
  108.             @Override
  109.             public void run() {
  110.                 demoLock3.m3();
  111.             }
  112.         }, "_3");
  113.         Thread t4 = new Thread(new Runnable() {
  114.             @Override
  115.             public void run() {
  116.                 demoLock3.m4();
  117.             }
  118.         }, "_4");
  119.         Thread t5 = new Thread(new Runnable() {
  120.             @Override
  121.             public void run() {
  122.                 demoLock3.m5();
  123.             }
  124.         }, "_5");
  125.         t1.start();
  126.         t2.start();
  127.         t3.start();
  128.         try {
  129.             Thread.sleep(3000);
  130.         } catch (InterruptedException e) {
  131.             e.printStackTrace();
  132.         }
  133.         t4.start();
  134.         try {
  135.             Thread.sleep(3000);
  136.         } catch (InterruptedException e) {
  137.             e.printStackTrace();
  138.         }
  139.         t5.start();
  140.     }
  141. }
  142. 输出：
  143. _1：进入m1
_1：m1释放锁，接收通唤醒知
_2：进入m2
_2：m2释放锁，接收通唤醒知
_3：进入m3
_3：m3释放锁，接收通唤醒知
_4：进入m4
_4：m4发出通知并唤醒：m1、m2
_1：继续执行 m1
_2：继续执行 m2
_5：进入m5
_5：m5发出通知并唤醒：m3
_3：继续执行 m3
常用方法
  1.          * 公平锁、非公平锁
  2.          * Lock lock = new ReentrantLock(boolean isFair)。
  3.          * tryLock()尝试去获取锁，并获得结果用false、true返回，并在给定的时间内去获取。
  4.          * isFair():是否公平锁。
  5.          * isLocked():是否锁定
  6.          * getHoldCount()：查询当前的线程保存的锁存在的个数，也就是调用lock的次数。
  7.          * lockinterruptibly():优先响应中断的锁。
  8.          * getQueueLength():返回正在等待获取此锁的线程数量。
  9.          * getWaitQueueLenth():获取返回等待与锁定相关的给定条件condition的线程数量。
  10.          * hasQueuedThread(Thread thread):查询指定的线程是否正在等待此锁。
  11.          * hasQueuedThread():查询是否有线程正在等待次锁。
  12.          * hasWaiters():查询是否有线程正在等待与此锁有关的condition条件。
posted @ 2017-08-10 02:05  逍遥叹!!  阅读(184)  评论(0)  编辑  收藏  举报