在前面我们将了很多关于同步的问题，然而在现实中，需要线程之间的协作。比如说最经典的生产者-消费者模型：当队列满时，生产者需要等待队列有空间才能继续往里面放入商品，而在等待的期间内，生产者必须释放对临界资源（即队列）的占用权。因为生产者如果不释放对临界资源的占用权，那么消费者就无法消费队列中的商品，就不会让队列有空间，那么生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产者交出对临界资源的占用权，并进入挂起状态。然后等待消费者消费了商品，然后消费者通知生产者队列有空间了。同样地，当队列空时，消费者也必须等待，等待生产者通知它队列中有商品了。这种互相通信的过程就是线程间的协作。
今天我们就来探讨一下Java中线程协作的最常见的两种方式：利用Object.wait()、Object.notify()和使用Condition
一.wait()、notify()和notifyAll()
1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。
2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）。调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，等待被唤醒，然后再等待再次获得此对象的锁（Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它并不释放对象锁）；
3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。
4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；
一个线程被唤醒不代表立即获取了对象的monitor，只有等调用完notify()或者notifyAll()并退出synchronized块，释放对象锁后，其余线程才可获得锁执行。
public class Test {
public static Object object = new Object();
public static void main(String[] args) {
Thread1 thread1 = new Thread1();
Thread2 thread2 = new Thread2();
thread1.start();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.start();
}
static class Thread1 extends Thread{
@Override
public void run() {
synchronized (object) {
try {
object.wait();
} catch (InterruptedException e) {
}
System.out.println("线程"+Thread.currentThread().getName()+"获取到了锁");
}
}
}
static class Thread2 extends Thread{
@Override
public void run() {
synchronized (object) {
object.notify();
System.out.println("线程"+Thread.currentThread().getName()+"调用了object.notify()");
}
System.out.println("线程"+Thread.currentThread().getName()+"释放了锁");
}
}
}线程Thread-1调用了object.notify()
线程Thread-1释放了锁
线程Thread-0获取到了锁二.Condition
synchronized与wait()和nitofy()/notifyAll()方法相结合可以实现等待/通知模型，ReentrantLock同样可以，但是需要借助Condition，且Condition有更好的灵活性，具体体现在：
1、一个Lock里面可以创建多个Condition实例，实现多路通知
2、notify()方法进行通知时，被通知的线程时Java虚拟机随机选择的，但是ReentrantLock结合Condition可以实现有选择性地通知，这是非常重要的
看一下利用Condition实现等待/通知模型的最简单用法，下面的代码注意一下，await()和signal()之前，必须要先lock()获得锁，使用完毕在finally中unlock()释放锁，这和wait()/notify()/notifyAll()使用前必须先获得对象锁是一样的：
package com.mook.condition;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class ThreadDomain40
{
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void await()
{
try
{
lock.lock();
System.out.println("await时间为：" + System.currentTimeMillis());
condition.await();
System.out.println("await等待结束");
}
catch (InterruptedException e)
{
e.printStackTrace();
}
finally
{
lock.unlock();
}
}
public void signal()
{
try
{
lock.lock();
System.out.println("signal时间为：" + System.currentTimeMillis());
condition.signal();
}
finally
{
lock.unlock();
}
}
}
class MyThread40 extends Thread {
private ThreadDomain40 td;
public MyThread40(ThreadDomain40 td) {
this.td = td;
}
public void run() {
td.await();
}
}
class MyThread41 extends Thread {
private ThreadDomain40 td;
public MyThread41(ThreadDomain40 td) {
this.td = td;
}
public void run() {
td.signal();
}
}
public class Test {
public static void main(String[] args) throws InterruptedException {
ThreadDomain40 td = new ThreadDomain40();
MyThread40 mt40 = new MyThread40(td);
MyThread41 mt41 = new MyThread41(td);
mt40.start();
Thread.sleep(3000);
mt41.start();
}
}
await时间为：1498918788180
signal时间为：1498918791180
await等待结束差值是3000毫秒也就是3秒，符合代码预期，成功利用ReentrantLock的Condition实现了等待/通知模型。其实这个例子还证明了一点，Condition的await()方法是释放锁的(wait()也是释放锁的，两者都throws InterruptedException，可以被中断)，原因也很简单，要是await()方法不释放锁，那么signal()方法又怎么能调用到Condition的signal()方法呢？
注意要是用一个Condition的话，那么多个线程被该Condition给await()后，调用Condition的signalAll()方法唤醒的是所有的线程。如果想单独唤醒部分线程该怎么办呢？new出多个Condition就可以了，这样也有助于提升程序运行的效率。使用多个Condition的场景是很常见的，像ArrayBlockingQueue里就有。
三.生产者-消费者模型的实现
什么是生产者/消费者模型
一种重要的模型，基于等待/通知机制。生产者/消费者模型描述的是有一块缓冲区作为仓库，生产者可将产品放入仓库，消费者可以从仓库中取出产品，生产者/消费者模型关注的是以下几个点：
1、生产者生产的时候消费者不能消费
2、消费者消费的时候生产者不能生产
3、缓冲区空时消费者不能消费
4、缓冲区满时生产者不能生产
生产者/模型作为一种重要的模型，它的优点在于：
1、解耦。因为多了一个缓冲区，所以生产者和消费者并不直接相互调用，这一点很容易想到，这样生产者和消费者的代码发生变化，都不会对对方产生影响，这样其实就把生产者和消费者之间的强耦合解开，变为了生产者和缓冲区/消费者和缓冲区之间的弱耦合
2、通过平衡生产者和消费者的处理能力来提高整体处理数据的速度，这是生产者/消费者模型最重要的一个优点。如果消费者直接从生产者这里拿数据，如果生产者生产的速度很慢，但消费者消费的速度很快，那消费者就得占用CPU的时间片白白等在那边。有了生产者/消费者模型，生产者和消费者就是两个独立的并发体，生产者把生产出来的数据往缓冲区一丢就好了，不必管消费者；消费者也是，从缓冲区去拿数据就好了，也不必管生产者，缓冲区满了就不生产，缓冲区空了就不消费，使生产者/消费者的处理能力达到一个动态的平衡
1.使用Object的wait()和notify()实现：
package com.mook.ProducerAndConsumer;
import java.util.LinkedList;
import java.util.PriorityQueue;
public class Test1 {
private int queueSize = 10;
private LinkedList<Integer> queue = new LinkedList<Integer>();
public static void main(String[] args) {
Test1 test1 = new Test1();
Producer producer = test1.new Producer();
Consumer consumer = test1.new Consumer();
producer.start();
consumer.start();
}
class Consumer extends Thread{
@Override
public void run() {
consume();
}
private void consume() {
while(true){
synchronized (queue) {
while(queue.size() == 0){
try {
System.out.println("队列空，等待数据");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
queue.notify();
}
}
queue.poll(); //每次移走队首元素
queue.notify();
System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
// for (int i = 0; i < Integer.MAX_VALUE; i++){} //让Producer有机会运行...
}
}
}
}
class Producer extends Thread{
@Override
public void run() {
produce();
}
private void produce() {
while(true){
synchronized (queue) {
while(queue.size() == queueSize){
try {
System.out.println("队列满，等待有空余空间");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
queue.notify();
}
}
queue.offer(1); //每次插入一个元素
queue.notify();
System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
}
}
}
}
}
2.使用Condition实现:
package com.mook.ProducerAndConsumer;
import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Created by mook on 2017/7/1.
*/
public class Test2 {
private int queueSize = 10;
private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
private Lock lock = new ReentrantLock();
private Condition notFull = lock.newCondition();
private Condition notEmpty = lock.newCondition();
public static void main(String[] args) {
Test2 test2 = new Test2();
Producer producer = test2.new Producer();
Consumer consumer = test2.new Consumer();
producer.start();
consumer.start();
}
class Consumer extends Thread{
@Override
public void run() {
consume();
}
private void consume() {
while(true){
lock.lock();
try {
while(queue.size() == 0){
try {
System.out.println("队列空，等待数据");
notEmpty.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.poll(); //每次移走队首元素
notFull.signal();
System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
} finally{
lock.unlock();
}
}
}
}
class Producer extends Thread{
@Override
public void run() {
produce();
}
private void produce() {
while(true){
lock.lock();
try {
while(queue.size() == queueSize){
try {
System.out.println("队列满，等待有空余空间");
notFull.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.offer(1); //每次插入一个元素
notEmpty.signal();
System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
} finally{
lock.unlock();
}
}
}
}
}小心假死:
生产者/消费者模型最终达到的目的是平衡生产者和消费者的处理能力，达到这个目的的过程中，并不要求只有一个生产者和一个消费者。可以多个生产者对应多个消费者，可以一个生产者对应一个消费者，可以多个生产者对应一个消费者。
假死就发生在上面三种场景下。理论分析就能说明问题，所以就不写代码了。代码要写也很简单，上面的两个例子随便修改一个，开一个生产者线程/多个消费者线程、开多个生产者线程/消费者线程、开多个生产者线程/多个消费者线程都可以。假死指的是全部线程都进入了WAITING状态，那么程序就不再执行任何业务功能了，整个项目呈现停滞状态。
比方说有生产者A和生产者B，缓冲区由于空了，消费者处于WAITING。生产者B处于WAITING，生产者A被消费者通知生产，生产者A生产出来的产品本应该通知消费者，结果通知了生产者B，生产者B被唤醒，发现缓冲区满了，于是继续WAITING。至此，两个生产者线程处于WAITING，消费者处于WAITING，系统假死。
上面的分析可以看出，假死出现的原因是因为notify的是同类，所以非单生产者/单消费者的场景，可以采取两种方法解决这个问题：
1、synchronized用notifyAll()唤醒所有线程、ReentrantLock用signalAll()唤醒所有线程
2、用ReentrantLock定义两个Condition，一个表示生产者的Condition，一个表示消费者的Condition，唤醒的时候调用相应的Condition的signal()方法就可以了
扫一扫
450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
