【java线程系列】java线程系列之线程间的交互wait()/notify()/notifyAll()及生产者与消费者模型

关于线程，博主写过java线程详解基本上把java线程的基础知识都讲解到位了，但是那还远远不够，多线程的存在就是为了让多个线程去协作来完成某一具体任务，比如生产者与消费者模型，因此了解线程间的协作是非常重要的，本博客主要讲解多个线程之间使用wait()/notify()/notifyAll()来进行交互的场景。

一wait()/notify()/notifyAll()：

首先我们来看一下它们的函数定义：

 /* Causes the current thread to wait until another thread invokes the
     * {@link java.lang.Object#notify()} method or the
     * {@link java.lang.Object#notifyAll()} method for this object.
     * The current thread must own this object's monitor. The thread
     * releases ownership of this monitor and waits until another thread
     * notifies threads waiting on this object's monitor to wake up
     * This method should only be called by a thread that is the owner
     * of this object's monitor.
     */
    public final void wait() throws InterruptedException {
        wait(0);
    }

    public final native void wait(long timeout) throws InterruptedException;

    /**
     * Wakes up a single thread that is waiting on this object's
     * monitor.If any threads are waiting on this object, one of them
     * is chosen to be awakened. The choice is arbitrary and occurs at
     * the discretion of the implementation. A thread waits on an object's
     * monitor by calling one of the {@code wait} methods.
     */

     public final native void notify();

    /* Wakes up all threads that are waiting on this object's monitor. A
     * thread waits on an object's monitor by calling one of the
     * {@code wait} methods.
     */
 public final native void notifyAll();

首先可以看到wait()/notify()/notifyAll()都是Object类中的方法，其次可以看到notify()/notifyAll()，与带一个参数的 wait(long timeout) 都被final native修饰的，即它们是本地方法且不允许被重写的。

另外从注释上我们可以获得以下信息：

1 调用某个对象的wait()方法能让当前线程阻塞，这个方法只能在拥有此对象的monitor的线程中调用（This method should only be called by a thread that is the owner of this     object's monitor.)。

2 调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程(Wakes up a single        thread that is waiting on this object's monitor.If any threads are waiting on this object, one of them is chosen to be awakened. )

3 调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程(Wakes up all threads that are waiting on this object's monitor.)

那么你可能会问为何这三个方法不是位于Thread类中而是在Object类中呢？这是因为这三个函数的操作都是与锁机制相关的，而在java中每个对象都对应一个对象锁，所以当某个线程等待某个对象的锁时，应该等待该对象来释放它自己的锁，即应该通过对象的方式来释放锁，所以将这些与锁相关的函数放在Object类中，因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。

下面我们来看一下这几个函数之间的协作使用的代码示范：

public class Main {
    publicstaticvoid main(String[] args) {
        ThreadOne one = new ThreadOne();
        one.start(); //启动一个子线程

        synchronized (one) {//synchronized (one) 代表当前线程拥有one对象的锁，线程为了调用wait()或notify()方法，该线程必须是那个对象锁的拥有者
            try {
                System.out.println("等待对象one完成计算。。。");
                one.wait(); //调用wait()方法的线程必须拥有对象one的锁，即必须在synchronized同步块中调用wait()
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("one对象计算的总和是：" + one.total);
        }
    }
}

public class ThreadOne extends Thread {
    int total; 

    publicvoid run() {
        synchronized (this) {
            for (int i = 0; i < 7; i++) {
                total += i;
            } 

            notify();  //完成计算后唤醒在此对象锁上等待的单个线程，在本例中主线程Main被唤醒
        }
    }
}

在该示例中定义了一个子线程ThreadOne，所以该程序存在两个线程，一个是默认的主线程Main，一个是自定义的ThreadOne，在自定义的线程中计算求和，在主线程中打印出计算结果，在Main线程中先启动子线程，然后调用wait()让主线程等待子线程运行，在子线程中计算完成后调用notify()唤醒Main线程打印出子线程中计算的结果。这样就做到了两个线程之间的交互。

二使用多线程模拟生产者与消费者模型：

生产者与消费者模型描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该模型的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

解决此模型的关键是让生产者在缓冲区满时交出对临界区的占用权，自己进入等待状态，等待消费者消费产品，等消费者消费了一定量产品后再唤醒生产者生产产品。

同样，当缓冲区为空时消费者也必须等待，等待生产者生产产品，等生产者生产了一定量产品后再唤醒消费者消费产品。

代码表示如下：

public class ProducerConsumer
{
	public static void main(String[] args)
	{
		SyncStack ss = new SyncStack();
		Producer p = new Producer(ss);
		Consumer c = new Consumer(ss);

		Thread t1 = new Thread(p);
		Thread t2 = new Thread(c);

		t1.start();
		t2.start();
	}
}

class SyncStack
{
	int cnt = 0;
	char[] data = new char[6];

	public synchronized void push(char ch)
	{
		while (cnt == data.length)
		{
			try
			{
				this.wait();	//wait是Object 类中的方法，不是Thread中的方法，Thread中wait也是继承自Object,
							   //this.wait();不是让当前对象wait，而是让当前锁定this对象的线程wait，同时释放对this的锁定。
							  //注意：如果该对象没有被锁定，则调用wait方法就会报错！即只有在同步方法或者同步代码块中才可以调用wait方法，notify同理
			}
			catch (Exception e)
			{
			}
		}
		this.notify();  //如果注释掉了本语句，可能会导致消费线程陷入阻塞(如果消费线程本身执行很慢的话，则消费线程永远不会wait，即永远不会阻塞)，因为消费线程陷入阻塞， 所以生产线程因此不停生产产品达到6个后也陷入阻塞，最后显示的肯定是“容器中现在共有6个字符!”
						//this.notify();叫醒一个现在正在wait  this对象的一个线程，如果有多个线程正在wait this对象，通常是叫醒最先wait this对象的线程,但具体是叫醒哪一个，这是由系统调度器控制，程序员无法控制
						// nority 和 notifyAll 都是Object 类中的方法	

		data[cnt] = ch;
		cnt++;

		System.out.printf("生产了: %c\n", ch);
		System.out.printf("容器中现在共有%d个字符!\n\n", cnt);
	}

	public synchronized char pop()
	{
		char ch;

		while (0 == cnt)
		{
			try
			{
				this.wait();
			}
			catch (Exception e)
			{
			}
		}
		this.notify();  //如果注释掉了本语句，可能会导致生产线程陷入阻塞(如果生产线程本身执行很慢的话，则生产线程永远不会wait，即永远不会阻塞)，因为生产线程陷入阻塞，消费线程因此不停取出产品，当容器中再也没有产品时消费线程也陷入阻塞，最后显示的肯定是“容器中现在共有0个字符!”

		ch = data[cnt-1];
		--cnt;

		System.out.printf("取出:  %c\n", ch);
		System.out.printf("容器中现在共有%d个字符!\n\n", cnt);

		return ch;
	}
}

class Producer implements Runnable
{
	SyncStack ss = null;

	public Producer(SyncStack ss)
	{
		this.ss = ss;
	}

	public void run()
	{
		char ch;

		//总共生产20个产品
		for (int i=0; i<20; ++i)
		{
			ch = (char)('a'+i);
			ss.push(ch);
//			try
//			{
//				Thread.sleep(500);
//			}
//			catch (Exception e)
//			{
//			}
		}
	}
}

class Consumer implements Runnable
{
	SyncStack ss = null;

	public Consumer(SyncStack ss)
	{
		this.ss = ss;
	}

	//总共消费20个产品
	public void run()
	{
		for (int i=0; i<20; ++i)
		{
			ss.pop();
			try
			{
				Thread.sleep(500);
			}
			catch (Exception e)
			{
			}
		}
	}
}

三总结：

1  如果调用某个对象的wait()方法，当前线程必须拥有这个对象的monitor（即锁），因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。

2调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待状态，等待后续再次获得此对象的锁，而Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它不会释放对象锁；

3 notify()方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。

调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法），nofityAll()方法能够唤醒所有正在等待该对象的monitor的线程

4一个线程被唤醒不代表它能立即获得对象的monitor，当且仅当调用完notify()或者notifyAll()且退出synchronized块，释放对象锁后，其余线程才可获得锁执行。