问题场景

  • 让线程按照约定的顺序进行输入和输出
  • A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照此顺序循环 10 轮

    实现流程

    通过： 在操作方法中添加标志位+ conditionA.signal(); 确定执行线程的顺序
    image.png

    流程代码

    ```java package com.atguigu.test; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;

public class DemoClass { / 通信对象:0—打印 A 1—-打印 B 2——打印 C / private int flag = 0; / 声明锁 / private Lock lock = new ReentrantLock(); / 声明钥匙 A / private Condition conditionA = lock.newCondition(); / 声明钥匙 B / private Condition conditionB = lock.newCondition(); / 声明钥匙 C / private Condition conditionC = lock.newCondition();

  1. /**
  2.  * A 打印 5 次
  3.  */
  4. public void printA( int j ) {
  5.     try {
  6.         lock.lock();
  7.         while (flag != 0) {
  8.             conditionA.await();
  9.         }
  10.         System.out.println(Thread.currentThread().getName() + "输出 A,第" + j + "轮开始");
  11.         /* 输出 5 次 A */
  12.         for (int i = 0; i < 5; i++) {
  13.             System.out.println("A");
  14.         }
  15.         /* 开始打印 B */
  16.         flag = 1;
  17.         /* 唤醒 B */
  18.         conditionB.signal();
  19.     } catch (Exception e) {
  20.         e.printStackTrace();
  21.     } finally {
  22.         lock.unlock();
  23.     }
  24. }
  26.     /**
  27.      * B 打印 10 次
  28.      */
  29. public void printB(int j)
  30. {
  31.     try {
  32.         lock.lock();
  33.         while ( flag != 1 )
  34.         {
  35.             conditionB.await();
  36.         }
  37.         System.out.println( Thread.currentThread().getName() + "输出 B,第" + j + "轮开始" );
  38.                 /* 输出 10 次 B */
  39.         for ( int i = 0; i < 10; i++ )
  40.         {
  41.             System.out.println( "B" );
  42.         }
  43.         /* 开始打印 C */
  44.         flag = 2;
  45.         /* 唤醒 C */
  46.         conditionC.signal();
  47.     }catch ( Exception e ) {
  48.         e.printStackTrace();
  49.     } finally {
  50.         lock.unlock();
  51.     }
  52. }

/**

  • C 打印 15 次 */
     public void printC( int j )
 {
     try {
         lock.lock();
         while ( flag != 2 )
         {
             conditionC.await();
         }
         System.out.println( Thread.currentThread().getName() + "输出 C,第" + j + "轮开始" );
                 /* 输出 15 次 C */
         for ( int i = 0; i < 15; i++ )
         {
             System.out.println( "C" );
         }
         System.out.println( "-----------------------------------------" );
         /* 开始打印 A */
         flag = 0;
         /* 唤醒 A */
         conditionA.signal();
     }catch ( Exception e ) {
         e.printStackTrace();
     } finally {
         lock.unlock();
     }
 }
    } ```

    测试类

    ```java package com.atguigu.test;

/**

  • volatile 关键字实现线程交替加减 / public class TestVolatile { /*
    • 交替加减
    • @param args */ public static void main( String[] args ) { DemoClass demoClass = new DemoClass(); new Thread( () - > {
               for ( int i = 1; i <= 10; i++ )
         {
             demoClass.printA( i );
         }
     }, "A 线程" ).start();
      new Thread( () - > {
               for ( int i = 1; i <= 10; i++ )
         {
             demoClass.printB( i );
         }
     }, "B 线程" ).start();
      new Thread( () - > {
               for ( int i = 1; i <= 10; i++ )
         {
             demoClass.printC( i );
         }
     }, "C 线程" ).start();
      } } ```

      注

      通过flag和