Java多线程编程之多生产多消费者示例
示例：分别创建并启动五个线性用于生产鸡蛋，消费鸡蛋；且鸡蛋最多可以有10个，消费鸡蛋只能是生产好了的鸡蛋，完成一边生产鸡蛋，一边消费鸡蛋的模型。
创建一个鸡蛋资源类EggRes，该类中封装有鸡蛋个数count，行为有生产鸡蛋，消费鸡蛋两个方法，
用同步锁来解决同步问题，等待唤醒机制完成线程间通讯，正常完成多生产多消费功能实现；
鸡蛋资源类EggRes代码如下：
class EggRes {
//最多能同时存在鸡蛋10个
int count;
boolean flag = true;
public void product() {
//鸡蛋小于10个时，生产鸡蛋线程为唤醒状态；鸡蛋为10个以上时，等待状态；
while (true) {
//执行while循环目的是使该线程可以生产很多鸡蛋，而不是生产一个鸡蛋就执行结束了
if (count >= 10) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程" + Thread.currentThread().getName() + ",生产了鸡蛋：" + ++count );
//每次生产一次鸡蛋，该线程就释放出锁，给予其他生产线程，消费线程竞争锁的机会
try {
wait(3000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
//此时，消费线程肯定为唤醒状态，那么唤醒所有线程
notifyAll();
}
}
public void consumer() {
//鸡蛋大于0个时，消费鸡蛋线程为唤醒状态； 鸡蛋为0时，等待状态
while (true) {
if (count <= 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//模拟消费鸡蛋需要耗时2s，这里线程没有释放出锁
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程" + Thread.currentThread().getName() + ",消费了鸡蛋:" + count--);
//每次消费一次鸡蛋，该线程就释放出锁，给予其他生产线程，消费线程竞争锁的机会
try {
wait(3000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
//此时，生产线性必须为唤醒状态，唤醒全部线程
notifyAll();
}
}
}生产线程类和消费线程类需要共享鸡蛋资源类EggRes的数据，于是通过构造函数传参获取共享数据；代码如下：
//生产线程
class MyProductThread extends Thread {
private EggRes er;
public MyProductThread(EggRes er) {
this.er = er;
}
@Override
public void run() {
synchronized (er){
er.product();
}
}
}
//消费线程
class MyConsumerThread extends Thread {
private EggRes er;
public MyConsumerThread(EggRes er) {
this.er = er;
}
@Override
public void run() {
synchronized (er) {
er.consumer();
}
}
}主函数调用如下：
public class MulProduct2Consumer {
public static void main(String[] args) {
//生产线程，消费线程的共享资源类EggRes
EggRes er = new EggRes();
MyProductThread[] mpts = new MyProductThread[5];
for (int i = 0; i < mpts.length; i++) {
mpts[i] = new MyProductThread(er);
mpts[i].start();
}
MyConsumerThread[] mcts = new MyConsumerThread[5];
for (int i = 0; i < mcts.length; i++) {
mcts[i] = new MyConsumerThread(er);
mcts[i].start();
}
}
}完整代码如下：
public class MulProduct2Consumer {
public static void main(String[] args) {
//生产线程，消费线程的共享资源类EggRes
EggRes er = new EggRes();
MyProductThread[] mpts = new MyProductThread[5];
for (int i = 0; i < mpts.length; i++) {
mpts[i] = new MyProductThread(er);
mpts[i].start();
}
MyConsumerThread[] mcts = new MyConsumerThread[5];
for (int i = 0; i < mcts.length; i++) {
mcts[i] = new MyConsumerThread(er);
mcts[i].start();
}
}
}
//鸡蛋类
class EggRes {
//最多能同时存在鸡蛋10个
int count;
boolean flag = true;
public void product() {
//鸡蛋小于10个时，生产鸡蛋线程为唤醒状态；鸡蛋为10个以上时，等待状态；
while (true) {
//执行while循环目的是使该线程可以生产很多鸡蛋，而不是生产一个鸡蛋就执行结束了
if (count >= 10) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程" + Thread.currentThread().getName() + ",生产了鸡蛋：" + ++count );
//每次生产一次鸡蛋，该线程就释放出锁，给予其他生产线程，消费线程竞争锁的机会
try {
wait(3000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
//此时，消费线程肯定为唤醒状态，那么唤醒所有线程
notifyAll();
}
}
public void consumer() {
//鸡蛋大于0个时，消费鸡蛋线程为唤醒状态； 鸡蛋为0时，等待状态
while (true) {
if (count <= 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//模拟消费鸡蛋需要耗时2s，这里线程没有释放出锁
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程" + Thread.currentThread().getName() + ",消费了鸡蛋:" + count--);
//每次消费一次鸡蛋，该线程就释放出锁，给予其他生产线程，消费线程竞争锁的机会
try {
wait(3000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
//此时，生产线性必须为唤醒状态，唤醒全部线程
notifyAll();
}
}
}
//生产线程
class MyProductThread extends Thread {
private EggRes er;
public MyProductThread(EggRes er) {
this.er = er;
}
@Override
public void run() {
synchronized (er){
er.product();
}
}
}
//消费线程
class MyConsumerThread extends Thread {
private EggRes er;
public MyConsumerThread(EggRes er) {
this.er = er;
}
@Override
public void run() {
synchronized (er) {
er.consumer();
}
}
}线程Thread-3,生产了鸡蛋：1
线程Thread-5,消费了鸡蛋: 1
线程Thread-4,生产了鸡蛋：1
线程Thread-2,生产了鸡蛋：2
线程Thread-1,生产了鸡蛋：3
线程Thread-4,生产了鸡蛋：4
线程Thread-5,消费了鸡蛋: 4
线程Thread-3,生产了鸡蛋：4
线程Thread-9,消费了鸡蛋: 4
线程Thread-0,生产了鸡蛋：4
线程Thread-9,消费了鸡蛋: 4
线程Thread-3,生产了鸡蛋：4
线程Thread-5,消费了鸡蛋: 4
线程Thread-4,生产了鸡蛋：4
线程Thread-1,生产了鸡蛋：5
线程Thread-2,生产了鸡蛋：6
线程Thread-8,消费了鸡蛋: 6
线程Thread-6,消费了鸡蛋: 5
线程Thread-7,消费了鸡蛋: 4
线程Thread-8,消费了鸡蛋: 3