JAVA 多线程使用Lock，Condition实现A,B,C,D依次执行，实现排它，同步通讯。

package com.study;

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


public class BlockingQueueDemo {
  public static void main(String[] args) {
    BlockingQueueDemo blockingQueueDemo = new BlockingQueueDemo();
    final BlockingQueueClass blockingQueueClass = blockingQueueDemo.new BlockingQueueClass();
    Thread thread = new Thread(new Runnable() {

      @Override
      public void run() {
        while (true) {
          blockingQueueClass.invokeA();
        }
      }
    });
    thread.start();

    Thread thread2 = new Thread(new Runnable() {

      @Override
      public void run() {
        while (true) {
          blockingQueueClass.invokeB();
        }
      }
    });
    thread2.start();

    Thread thread3 = new Thread(new Runnable() {

      @Override
      public void run() {
        while (true) {
          blockingQueueClass.invokeC();
        }
      }
    });
    thread3.start();

    Thread thread4 = new Thread(new Runnable() {

      @Override
      public void run() {
        while (true) {
          blockingQueueClass.invokeD();
        }
      }
    });
    thread4.start();
  }

  class BlockingQueueClass {
    Lock lock = new ReentrantLock();
    Condition conditionA = lock.newCondition();
    Condition conditionB = lock.newCondition();
    Condition conditionC = lock.newCondition();
    Condition conditionD = lock.newCondition();
    boolean syncA = true;
    boolean syncB = false;
    boolean syncC = false;
    boolean syncD = false;

    public void invokeA() {
      lock.lock();
      try {
        while (!syncA) {
          try {
            conditionA.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        syncA = false;
        syncB = true;
        System.out.println("invoke A....");
        conditionB.signal();
      } catch (Exception e) {
        e.printStackTrace();
      } finally {
        lock.unlock();
      }
    }

    public void invokeB() {
      lock.lock();
      try {
        while (!syncB) {
          try {
            conditionB.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        syncB = false;
        syncC = true;
        System.out.println("invoke B....");
        conditionC.signal();
      } catch (Exception e) {
        e.printStackTrace();
      } finally {
        lock.unlock();
      }
    }

    public void invokeC() {
      lock.lock();
      try {
        while (!syncC) {
          try {
            conditionC.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        syncC = false;
        syncD = true;
        System.out.println("invoke C....");
        conditionD.signal();
      } catch (Exception e) {
        e.printStackTrace();
      } finally {
        lock.unlock();
      }
    }
    public void invokeD() {
      lock.lock();
      try {
        while (!syncD) {
          try {
            conditionD.await();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        syncD = false;
        syncA = true;
        System.out.println("invoke D....");
        conditionA.signal();
      } catch (Exception e) {
        e.printStackTrace();
      } finally {
        lock.unlock();
      }
    }
  }
}