java线程生产者消费者_Java多线程实现生产者消费者模式

用java实现生产者消费者模式，在全部代码之后会对重点、难点一一讲解！

以下是全部代码：

class Demo7 {

public static void main(String[] args) {

//资源对象

Resource r = new Resource();

//生产者

Producer pro = new Producer(r);

//消费者

Consumer con = new Consumer(r);

Thread t1 = new Thread(pro);

Thread t2 = new Thread(pro);

Thread t3 = new Thread(con);

Thread t4 = new Thread(con);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

class Resource {

private String name;

private int count = 1;

private boolean flag = false;// false 表示存储的货物为空，ture 则反之。

public synchronized void set(String name) // 生产产品

{

while (flag)

try {

wait();

} catch (Exception e) {

e.printStackTrace();

}

this.name = name + "---" + count++;//例如：Thread-0....生产者....+商品+---1

System.out.println(Thread.currentThread().getName() + "....生产者...."

+ this.name);

flag = true;

this.notifyAll();

}

public synchronized void out()// 消费产品

{

while (!flag)

try {

wait();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+ "........消费者........." + this.name);

flag = false;

this.notifyAll();

}

}

/** * * 生产者类 * */

class Producer implements Runnable {

private Resource res; // 组合 定义了一个资源类变量

Producer(Resource res) {

this.res = res;

}

public void run() {

while (true) {

res.set("+商品+");

}

}

}

/** * * 消费者类 * */

class Consumer implements Runnable {

private Resource res;

Consumer(Resource res) {

this.res = res;

}

public void run() {

while (true) {

res.out();

}

}

}

运行结果(因为是无限循环的生产消费，所以提供部分截图)：

Thread-0....生产者....+商品+---1

Thread-3........消费者.........+商品+---1

Thread-1....生产者....+商品+---2

Thread-2........消费者.........+商品+---2

Thread-0....生产者....+商品+---3

Thread-3........消费者.........+商品+---3

Thread-1....生产者....+商品+---4

Thread-2........消费者.........+商品+---4

Thread-0....生产者....+商品+---5

Thread-3........消费者.........+商品+---5

Thread-1....生产者....+商品+---6

Thread-2........消费者.........+商品+---6

Thread-0....生产者....+商品+---7

Thread-3........消费者.........+商品+---7

Thread-1....生产者....+商品+---8

Thread-2........消费者.........+商品+---8

.....................................

以下为详细讲解部分(请不要复制下面的代码)：

1.

先看main方法

public static void main(String[] args) {

//资源对象

Resource r = new Resource();2.

//生产者

Producer pro = new Producer(r);3.

//消费者

Consumer con = new Consumer(r);4.

Thread t1 = new Thread(pro);生产

Thread t2 = new Thread(pro);生产

Thread t3 = new Thread(con);消费

Thread t4 = new Thread(con);消费

t1.start();

t2.start();

t3.start();

t4.start();

这里创建了四个线程。1、2为生产者；34为消费者

}

接下来，按照程序执行顺序讲解：

2.

class Producer implements Runnable {

private Resource res; // 组合 定义了一个资源类变量

获得“资源对象”

Producer(Resource res) {

this.res = res;

}都懂

public void run() {

while (true) {注意，这里是无限循环

res.set("+商品+");

}

}

}

/** * * 消费者类 * */

class Consumer implements Runnable {

private Resource res;

Consumer(Resource res) {

this.res = res;

}

public void run() {

while (true) {注意，这里是无限循环

res.out();

}

}

}

下面是超级重点了，以为本篇文章存在的价值所在

class Resource {

private String name;

private int count = 1;

private boolean flag = false;// false 表示存储的货物为空，ture 则反之。

public synchronized void set(String name) // 生产产品

{

while (flag)

try {

wait();

} catch (Exception e) {

e.printStackTrace();

}

this.name = name + "---" + count++;//例如：Thread-0....生产者....+商品+---1

System.out.println(Thread.currentThread().getName() + "....生产者...."

+ this.name);

flag = true;

this.notifyAll();

}

public synchronized void out()// 消费产品

{

while (!flag)

try {

wait();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()

+ "........消费者........." + this.name);

flag = false;

this.notifyAll();

}

}

假设先执行out()，当前为flag为false，进入out()后先上锁(遇到了synchronized)，可是while判断后，进入wait()，(这个wait方法会释放CPU资源同时解锁，当该线程被唤醒的时候，会从上锁的位置开始)，假设现在运气很差，又一次被消费者抢到了，那么剩下的那个消费着即使进入了out可是因为当前的flag也会被wait()，所以，一开始只有当一个生产者进入后，才能不被wait()，同时上锁，不允许第二个生产者“生产”，执行完set()后，flag变为true，然后通过notifyAll来唤醒之前被wait的两个消费者线程(这是说的比较坏的情况)，由于当前flag为false所以，同理当前能够不被wait的也只有消费者，这两个线程来抢夺然后上锁，就这样四个线程反反复复的抢夺，两两为一组，如此循环下去，就会看到生产了马上就要消费，因为最多可以存储一个货物(简单理解为：true、false)。