synchronized + wait/notifyAll

实现思路：判断当前打印数字和线程数的取余，不等于当前线程则处于等待状态。循环结束唤醒所有等待线程。

public class PrintExample {//创建一个公共锁对象private static final Object Lock = new Object();//执行线程数private static final int THREAD_COUNT = 3;//打印数字的起始点private static volatile int START = 0;//打印数字的结束点private static final int END = 100;private static class Print implements Runnable{private final int index;public Print(int index){this.index = index;}@Overridepublic void run() {while(START<END){synchronized (Lock){//START和线程数进行取余，如果不等于当前线程的则等待while(START % THREAD_COUNT != index){try{Lock.wait();}catch (Exception e){e.printStackTrace();}}//否则进行输出if(START<=END){System.out.println("Thread" + (index+1) +  ",打印结果：" + START);}START++;//唤醒等待线程Lock.notifyAll();}}}public static void main(String[] args) {for(int i = 0; i < THREAD_COUNT; i++){new Thread(new Print(i)).start();}}}
}

ReetrantLock + await/signalAll

实现思路：实现方式和synchronized + wait/notifyAll儿乎完全一样。我们只需要4步：
1.synchronized 替换为ReentrantLock

2.根据锁对象创建一个Condition对象

3.wait替换成await

4.notifyAll 替换为 signalAll

public class PrintExample {//创建一个公共锁对象private static final ReentrantLock Lock = new ReentrantLock();//根据锁对象创建一个Condition对象private static final Condition CONDITION = Lock.newCondition();//执行线程数private static final int THREAD_COUNT = 3;//打印数字的起始点private static volatile int START = 0;//打印数字的结束点private static final int END = 100;private static class Print implements Runnable{private final int index;public Print(int index){this.index = index;}@Overridepublic void run() {while(START<END){Lock.lock();try {//START和线程数进行取余，如果不等于当前线程的则等待while(START % THREAD_COUNT != index){try{CONDITION.await();}catch (Exception e){e.printStackTrace();}}//否则进行输出if(START<=END){System.out.println("Thread" + (index+1) +  ",打印结果：" + START);}START++;//唤醒等待线程CONDITION.signalAll();}catch (Exception e){e.printStackTrace();}finally {Lock.unlock();}}}public static void main(String[] args) {for(int i = 0; i < THREAD_COUNT; i++){new Thread(new Print(i)).start();}}}
}

ReetrantLock + await/signal

因为Condition相对wait/notify方式，可以唤醒指定线程。那我们就完全不用每次都唤醒全部线程，仅需要唤醒下一次需要执行的线程就可以了。
相比较 ReentrantLock + await/signalAll 改进方法：
1.去除公共的Condition对象，替换为List<Condition> conditions；
2.调用"下一个线程的"Condition对象的signal方法唤醒下一个线程；

public class PrintExample {//创建一个公共锁对象private static final ReentrantLock Lock = new ReentrantLock();//根据锁对象创建一个Condition对象//private static final Condition CONDITION = Lock.newCondition();//执行线程数private static final int THREAD_COUNT = 3;//打印数字的起始点private static volatile int START = 0;//打印数字的结束点private static final int END = 100;private static class Print implements Runnable{private final int index;private final List<Condition> conditions;public Print(int index,List<Condition> conditions){this.index = index;this.conditions = conditions;}//只唤醒下一个线程private void signalNext(){int nextIndex = (index + 1) % THREAD_COUNT;conditions.get(nextIndex).signal();}@Overridepublic void run() {while(START<END){Lock.lock();try {//START和线程数进行取余，如果不等于当前线程的则等待while(START % THREAD_COUNT != index){try{conditions.get(index).await();}catch (Exception e){e.printStackTrace();}}//否则进行输出if(START<=END){System.out.println("Thread" + (index+1) +  ",打印结果：" + START);}START++;//唤醒等待线程signalNext();}catch (Exception e){e.printStackTrace();}finally {Lock.unlock();}}}public static void main(String[] args) {List<Condition> conditionList = new ArrayList<>();conditionList.add(Lock.newCondition());conditionList.add(Lock.newCondition());conditionList.add(Lock.newCondition());for(int i = 0; i < THREAD_COUNT; i++){new Thread(new Print(i,conditionList)).start();}}}
}

此处使用 List<Condition> conditions让每个线程都拥有属于自己的condition，这样可以单独唤醒和等待。

Condition是什么

概念：

condition可以理解为条件队列。当一个线程在调用了其await方法以后，直到线程等待的某个条件为真的时候才会被唤醒。Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现