为了方便理解先看一段代码:
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test01 {
public static void main(String[] args) {
final Business b = new Business();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 50; i++) {
b.sub(i);
}
}
}).start();
for (int i = 1; i <= 50; i++) {
b.main(i);
}
}
}
class Business {
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
/*
* 执行标志
* true表示main执行
* false表示sub执行
*/
private boolean flag = true;
public void main(int i) {
lock.lock();
while (!flag) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//flag为true时执行
try {
System.out.println("loop:" + i + "-" + "mainThread");
condition.signal();
flag = false;
} finally {
lock.unlock();
}
}
public void sub(int i) {
lock.lock();
while (flag) {
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//flag为false时执行
try {
System.out.println("loop:" + i + "-" + "subThread");
condition.signal();
flag = true;
} finally {
lock.unlock();
}
}
}
这段代码的是实现让两个线程轮流执行的功能:
一段输出结果:
同步器AbstractQueuedSynchronizer(AQS)维护了一个当前等待资源的队列,AQS会在资源被释放后,依次唤醒队列中从前到后的所有节点,使他们对应的线程恢复执行。直到队列为空。
Condition也维护了一个队列,该队列的作用是维护一个等待signal信号的队列,两个队列的作用是不同,事实上,每个线程也仅仅会同时存在以上两个队列中的一个,流程是这样的:
线程1调用reentrantLock.lock时,线程被加入到AQS的等待队列中。
线程1调用await方法被调用时,该线程从AQS中移除,对应操作是锁的释放。
接着马上被加入到Condition的等待队列中,以为着该线程需要signal信号。
线程2,因为线程1释放锁的关系,被唤醒,并判断可以获取锁,于是线程2获取锁,并被加入到AQS的等待队列中。
线程2调用signal方法,这个时候Condition的等待队列中只有线程1一个节点,于是它被取出来,并被加入到AQS的等待队列中。 此时,线程1 并没有被唤醒!
signal方法执行完毕,线程2调用reentrantLock.unLock()方法,释放锁。这个时候因为AQS中只有线程1,于是,AQS释放锁后按从头到尾的顺序唤醒线程时,线程1被唤醒,于是线程1回复执行。
直到释放所整个过程执行完毕。
可以看到,整个协作过程是靠结点在AQS的等待队列和Condition的等待队列中来回移动实现的,Condition作为一个条件类,很好的自己维护了一个等待信号的队列,并在适时的时候将结点加入到AQS的等待队列中来实现的唤醒操作。