使用Condition控制线程按照顺序执行

使用Condition对象可以对线程执行的顺序进行排序规划：

package Lock.condition123;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Run {
   volatile private static int nextPrintWho = 1;
   private static ReentrantLock lock = new ReentrantLock();
   final private static Condition conditionA = lock.newCondition();
   final private static Condition conditionB = lock.newCondition();
   final private static Condition conditionC = lock.newCondition();

   public static void main(String[] args) {
       Thread ThreadA = new Thread() {
           @Override
           public void run() {
               try {
                   lock.lock();
                   while (nextPrintWho != 1) {
                       conditionA.await();
                   }
                   System.out.println("A：执行了");
                   nextPrintWho = 2;
                   conditionB.signalAll();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               } finally {
                   lock.unlock();
               }
           }
       };
       Thread ThreadB = new Thread() {
           @Override
           public void run() {
               try {
                   lock.lock();
                   while (nextPrintWho != 2) {
                       conditionA.await();
                   }
                   System.out.println("B：执行了");
                   nextPrintWho = 3;
                   conditionC.signalAll();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               } finally {
                   lock.unlock();
               }
           }
       };
       Thread ThreadC = new Thread() {
           @Override
           public void run() {
               try {
                   lock.lock();
                   while (nextPrintWho != 3) {//条件
                       conditionA.await();
                   }
                   System.out.println("C：执行了");
                   nextPrintWho = 1;
                   conditionA.signalAll();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               } finally {
                   lock.unlock();//释放锁
               }
           }
       };
       new Thread(ThreadA).start();
       new Thread(ThreadB).start();
       new Thread(ThreadC).start();
   }
}

执行的结果：

A：执行了
B：执行了
C：执行了