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();
}
}
}
}