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

Posted 2022-02-08 小志的博客

目录

• • 一、锁绑定多个条件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();
      
  
  

• 输出结果如下图：