线程的交互（No.8）

线程的交互

1、基础知识

三个方法：

notify()唤醒 在此 对象监视器上 等待的 单个 线程。

notifyall()::唤醒 在此 对象监视器上 等待的 所有 线程。

wait()::导致当前的线程等待，直到其他线程调用此对象的norify()方法或notifyAll()方法。

关键点是：必须从同步环境内调用wait()、notify()、notifyAll()方法。线程不能调用对象上等待或通知的方法，除非它拥有那个对象的锁。

例：/**

* 计算输出其他线程锁计算的数据

*/

class ThreadA {

public static void main(String[] args) {

ThreadB b = new ThreadB();

//启动计算线程

b.start();

//线程A拥有b对象上的锁。线程为了调用wait()或notify()方法，该线程必须是那个对象锁的拥有者

synchronized (b) {

try {

System.out.println("等待对象b完成计算。。。");

//当前线程A等待

b.wait(); //这里并不是让b去wait，是b的所有者线程wait，但是这个线程的苏醒的条件是b的notify或notifyAll方法的调用而且

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("b对象计算的总和是：" + b.total);

}

}

}

/**

* 计算1+2+3 ... +100的和

*

* @author leizhimin 2008-9-15 13:20:49

*/

class ThreadB extends Thread {

int total;

public void run() {

System.out.println("xxxxxxxxxxxxxxxxxrrrrrrrrrrrrrrrrrrrrrx");

synchronized (this) {

System.out.println("xxxxxxxxxxxxxxxxxx");

for (int i = 0; i < 101; i++) {

total += i;

}

//（完成计算了）唤醒在此对象监视器上等待的单个线程，在本例中线程A被唤醒

notify();

}

}

}

千万注意：

当在对象上调用wait()方法时，执行该代码的线程立即放弃它在对象上的锁。然而调用notify()时，并不意味着这时线程会放弃其锁。如果线程仍然在完成同步代码，则线程在移出之前不会放弃锁。因此，只要调用notify()并不意味着这时该锁变得可用。

2、norifyAll()

如果需要通知等待某个对象的所有线程，则用notifyAll（）让所有在此对象上等待的线程重出等待区，返回到可运行状态。就好比五个人抢一个苹果，当其中一个人强到之后，另外四个人就会休眠状态，然后，当那个人把苹果放下之后notifyAll（）会被调用，使得其它四个人都会苏醒，他们四个就会去强那个苹果，当又有人强到苹果之后，wait（）方法调用，没有强到苹果的三个人休眠，强到苹果的那个人把苹果放下之后，notifyAll（）方法被调用，以此类推，直到所有的人都抢了一次苹果为止。

3、生产者消费者模型

对于此模型，应该明确一下几点：

1、生产者仅仅在仓储未满时候生产，仓满则停止生产。

2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。

3、当消费者发现仓储没产品可消费时候会通知生产者生产。

4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。

例子：/

public class Test {

public static void main(String[] args) {

Godown godown = new Godown(30)；

Consumer c1 = new Consumer(50, godown);

Consumer c2 = new Consumer(20, godown);

Consumer c3 = new Consumer(30, godown)；

Producer p1 = new Producer(10, godown);

Producer p2 = new Producer(10, godown);

Producer p3 = new Producer(10, godown);

Producer p4 = new Producer(10, godown);

Producer p5 = new Producer(10, godown);

Producer p6 = new Producer(10, godown);

Producer p7 = new Producer(80, godown);

c1.start();

c2.start();

c3.start();

p1.start();

p2.start();

p3.start();

p4.start();

p5.start();

p6.start();

p7.start();

}

}

* 仓库

*/

class Godown {

public static final int max_size = 100; // 最大库存量

public int curnum; // 当前库存量

Godown() {

}

Godown(int curnum) {

this.curnum = curnum;

}

/**

* 生产指定数量的产品

*/

public synchronized void produce(int neednum) {

// 测试是否需要生产

while (neednum + curnum > max_size) {

System.out.println("要生产的产品数量" + neednum + "超过剩余库存量"

+ (max_size - curnum) + "，暂时不能执行生产任务!");

try {

// 当前的生产线程等待

wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

// 满足生产条件，则进行生产，这里简单的更改当前库存量

curnum += neednum;

System.out.println("已经生产了" + neednum + "个产品，现仓储量为" + curnum);

// 唤醒在此对象监视器上等待的所有线程

notifyAll();

}

/**

* 消费指定数量的产品

*

* @param neednum

*/

public synchronized void consume(int neednum) {

// 测试是否可消费

while (curnum < neednum) {

try {

// 当前的生产线程等待

wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

// 满足消费条件，则进行消费，这里简单的更改当前库存量

curnum -= neednum;

System.out.println("已经消费了" + neednum + "个产品，现仓储量为" + curnum);

// 唤醒在此对象监视器上等待的所有线程

notifyAll();

}

}

/**

* 生产者

*/

class Producer extends Thread {

private int neednum; // 生产产品的数量

private Godown godown; // 仓库

Producer(int neednum, Godown godown) {

this.neednum = neednum;

this.godown = godown;

}

public void run() {

// 生产指定数量的产品

godown.produce(neednum);

}

}

/**

* 消费者

*/

class Consumer extends Thread {

private int neednum; // 生产产品的数量

private Godown godown; // 仓库

Consumer(int neednum, Godown godown) {

this.neednum = neednum;

this.godown = godown;

}

public void run() {

// 消费指定数量的产品

godown.consume(neednum);

}

}