Java并发多线程编程——锁绑定多个条件Condition示例

admin管理员组

文章数量:1599422

目录

• • 一、锁绑定多个条件Condition概述
  • 二、锁绑定多个条件Condition示例代码

一、锁绑定多个条件Condition概述

• ReentrantLock 用来实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像synchronized 要么随机唤醒一个线程，要么唤醒全部线程。

二、锁绑定多个条件Condition示例代码

• 示例需求

  示例需求：
  多线程之间按顺序调用，实现A->B->C 三个线程启动，要求如下：
  A线程 打印1次，  B线程 打印2次，  C线程 打印3次，
  紧接着
  A线程 打印1次，  B线程 打印2次，  C线程 打印3次，
  。。。。
  一共遍历3次
  

• 示例代码

  import java.util.concurrent.locks.Condition;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReentrantLock;
  /**
   *  @description:  1、lock有什么好处？
   *                   锁绑定多个条件Condition：即实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像synchronized 要么随机唤醒一个线程，要么唤醒全部线程。
   *                 2、示例需求：
   *                   多线程之间按顺序调用，实现A->B->C 三个线程启动，要求如下：
   *                   A线程 打印1次，  B线程 打印2次，  C线程 打印3次，
   *                   紧接着
   *                   A线程 打印1次，  B线程 打印2次，  C线程 打印3次，
   *                   。。。。
   *                   一共遍历3次
   * @author: xz
   */
  class MyResource{
      private int number =1;//A线程用1表示，B线程用2表示，C线程用3表示
  
      private Lock lock=new ReentrantLock();
      private Condition c1=lock.newCondition();
      private Condition c2=lock.newCondition();
      private Condition c3=lock.newCondition();
  
      public void print1(){
          lock.lock();
          try {
              //1、判断!=1,说明A线程不输出，等待
              while(number !=1){
                  c1.await();
              }
              //2、A线程输出1次
              for(int i=1;i<=1;i++){
                  System.out.println(Thread.currentThread().getName()+"\t"+number);
              }
              //3、先修改标志位,然后A线程通知B线程
              number=2;
              c2.signal();
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              lock.unlock();
          }
      }
  
      public void print2(){
          lock.lock();
          try {
              //1、判断!=2,说明B线程不输出，等待
              while(number !=2){
                  c2.await();
              }
              //2、B线程输出2次
              for(int i=1;i<=2;i++){
                  System.out.println(Thread.currentThread().getName()+"\t"+number);
              }
              //3、先修改标志位,然后B线程通知C线程
              number=3;
              c3.signal();
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              lock.unlock();
          }
      }
  
      public void print3(){
          lock.lock();
          try {
              //1、判断!=3,说明C线程不输出，等待
              while(number !=3){
                  c3.await();
              }
              //2、B线程输出3次
              for(int i=1;i<=3;i++){
                  System.out.println(Thread.currentThread().getName()+"\t"+number);
              }
              //3、先修改标志位,然后C线程通知A线程
              number=1;
              c1.signal();
          }catch (Exception e){
              e.printStackTrace();
          }finally {
              lock.unlock();
          }
      }
  }
  public class SyncAndReentrantLockDemo {
      public static void main(String[] args) {
          MyResource myResource=new MyResource();
  
          new Thread(()->{
              for (int i=1;i<=3;i++){
                  myResource.print1();
              }
          },"A线程").start();
  
          new Thread(()->{
              for (int i=1;i<=3;i++){
                  myResource.print2();
              }
          },"B线程").start();
  
          new Thread(()->{
              for (int i=1;i<=3;i++){
                  myResource.print3();
              }
          },"C线程").start();
      }
  }
  

• 输出结果如下图：
  

本文标签： 多个示例绑定多线程条件