JUC实现精确顺序访问（线程通信例题）

在JUC编程中可以通过Condition类来进行精确阻塞与唤醒。

Condition类主要有两种方法：

1，Condition.await():使当前线程陷入阻塞，并释放锁。

2,  Condition.signal():唤醒该Condition对象所在的线程。

下面有个例题可以帮助理解。

题目要求：创建三个线程，线程1打印 " -A- " 5次 ，线程2打印" -B-" 10次，线程3打印 "-C-" 15次，并按照 A->B->C顺序进行打印，重复10轮。

以下是实现过程

package Condtion;

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

public class Wait_Demo {
	public static void main(String[] args) {
		Print print =new Print();

		//设置开始点——1对应A，2对应B，3对应C
		print.setflag(1);

		//lambda表达式，启动三个线程，为了方便描述，就命名它们分别为线程1,线程2,线程3
		new Thread(()->{
			try {
				for(int i=0;i<10;i++) {
					print.printA();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();
		new Thread(()->{
			try {
				for(int i=0;i<10;i++)
					print.printB();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();
		new Thread(()->{
			try {
				for(int i=0;i<10;i++)
					print.printC();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}).start();

	}
}

class Print{
	//锁对象为该类的对象
	private Lock lock=new ReentrantLock();

	//创建三个Condition类，它们是进行线程通信的核心
	private Condition ca=lock.newCondition();
	private Condition cb=lock.newCondition();
	private Condition cc=lock.newCondition();

	//flag可以设置起点
	private int flag;
	public  void setflag(int flag){
		this.flag=flag;
	}
	private  int count=0;

	public void printA() throws InterruptedException {
		lock.lock();//上锁
		try {
			//如果flag!=1则ca所在的线程阻塞，并释放锁
			while(flag!=1)//为了避免虚假唤醒需将if改成while。
				ca.await();
			System.out.println("第"+(++count)+"轮");
			for(int i=0;i<5;i++){
				System.out.print("-A-");
			}
			flag=2;//设置目标点为2
			cb.signal();//唤醒cb所在的线程.
		} finally {
			lock.unlock();//解锁
		}
	}public void printB() throws InterruptedException {
		lock.lock();
		try {
			//如果flag!=2则cb所在的线程阻塞，并释放锁
			while(flag!=2)
				cb.await();
			for(int i=0;i<10;i++){
				System.out.print("-B-");
			}
			flag=3;
			cc.signal();//唤醒cc所在的线程
		} finally {
			lock.unlock();
		}
	}public void printC() throws InterruptedException {
		lock.lock();
		try {
			//如果flag!=3则cc所在的线程阻塞，并释放锁
			while(flag!=3)
				cc.await();
			for(int i=0;i<15;i++){
				System.out.print("-C-");
			}
			System.out.println();
			flag=1;
			ca.signal();//唤醒ca所在的线程
		} finally {
			lock.unlock();
		}
	}
}

运行结果：

代码讲解：

创建三个线程（通过lambda表达式）使其处于就绪状态，每个线程分别调用资源类（Print）中的方法，因为三个线程均处于就绪状态，所以不确定谁先拿到锁，就会有三个情况。

情况1：假设线程2先拿到锁，那么其他线程则处于等待状态，线程2继续执行，此时由于设置的flag=1,那么就会调用await（）方法，使线程2就会陷入阻塞同时释放锁，此时又会有两个情况：是线程1还是线程2拿到锁。因为flag=1，所以线程2拿到锁会陷入阻塞并释放锁，线程1拿到锁就继续向下执行，最后设置flag=2并唤醒Condition对象cb所在的线程2，但此时线程1仍然握着锁，所以线程2处于就绪状态。

线程1解锁后，此时线程2就会和线程3竞争锁，谁抢到锁是随机的，但是由于刚才设置了flag=2，就只有线程2拿到锁后才会执行，以此循环，达到 A->B->C顺序循环打印的效果。

情况2：线程3先拿到锁，过程同上......

情况3：线程1先拿到锁，由于初始设置的flag为1，线程1就不会陷入阻塞状态，继续执行下去，最后设置flag为2，然后执行signal方法，由于没有线程处于await状态所以这一步没有意义，但是不会对程序造成影响，线程1解锁后，线程2和线程3均有可能拿到锁，过程同情况1。

                                                                      -------萌新的Java学习博客，如果有错误欢迎指出。