三个线程轮流执行顺序打印ABC（二）：使用Lock+Condition实现

需求：有三个线程轮流执行，第一个线程打印A，第二个线程打印B，第三个线程打印C……循环10次。

思路：三个线程对应三个Condition、三个Condition共享一个Lock、一个线程轮流状态state。线程拿到锁之后，通过state进行判断，如果没有轮到当前线程打印，则通过当前线程对应的Condition使当前线程进入等待状态，并释放锁；如果轮到当前线程打印，则执行打印、更改state状态以及通过下一个线程对应的Condition唤醒下一个线程；……循环10次。

效率：线程不满足条件等待，满足条件执行打印，并唤醒下一个线程，效率比较高。

实现代码：

package edu.self.multithread;

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

/**
 * Created by SunYanhui on 2017/12/7.
 */
public class MultipleThreadRotationUsingExplicitLockCondition {
    public static void main(String[] args) {
        PrintABCUsingCondition printABC = new PrintABCUsingCondition();
        new Thread(() -> printABC.printA()).start();
        new Thread(() -> printABC.printB()).start();
        new Thread(() -> printABC.printC()).start();
    }
}

class PrintABCUsingCondition {
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();
    private int state = 0;
    //private int attempts = 0;

    public void printA() {
        print("A", 0, conditionA, conditionB);
    }

    public void printB() {
        print("B", 1, conditionB, conditionC);
    }

    public void printC() {
        print("C", 2, conditionC, conditionA);
    }

    private void print(String name, int currentState, Condition currentCondition, Condition nextCondition) {
        for (int i = 0; i < 10; ) {
            lock.lock();
            try {
                //System.out.println(Thread.currentThread().getName()+" try to print "+name+", attempts : "+(++attempts));
                while (state % 3 != currentState) {
                    currentCondition.await();
                }
                System.out.println(Thread.currentThread().getName() + " print " + name);
                state++;
                i++;
                nextCondition.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}