并发协作:多线程中的生产者与消费者模型

对于多线程程序来说,不管任何编程语言,生产者和消费者模型都是最经典的。就像学习每一门编程语言一样,Hello World!都是最经典的例子。

实际上,准确说应该是“生产者-消费者-仓储”模型,离开了仓储,生产者消费者模型就显得没有说服力了。

对于此模型,应该明确一下几点:

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

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

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

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

此模型将要结合java.lang.Object的wait与notify、notifyAll方法来实现以上的需求。这是非常重要的。

看下面的代码:<引:http://www.cnblogs.com/riskyer/p/3263032.html>

/**
 * Java线程:并发协作-生产者消费者模型
 *
 */
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;
    }

    /**
     * 生产指定数量的产品
     *
     * @param neednum
     */
    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) {
            System.out.println("-----准备消费" + neednum + ",当前剩余" + curnum + ",暂不能消费!");
            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);
    }
}

执行结果如下:(注意:每次运行的结果都不同)

情况1:死锁情况

-----准备消费50,当前剩余30,暂不能消费!
已经消费了30个产品,现仓储量为0
-----准备消费20,当前剩余0,暂不能消费!
已经生产了10个产品,现仓储量为10
-----准备消费50,当前剩余10,暂不能消费!
已经生产了10个产品,现仓储量为20
已经生产了10个产品,现仓储量为30
已经消费了20个产品,现仓储量为10
已经生产了10个产品,现仓储量为20
已经生产了10个产品,现仓储量为30
已经生产了10个产品,现仓储量为40
------要生产的产品数量80超过剩余库存量60,暂时不能执行生产任务!
-----准备消费50,当前剩余40,暂不能消费!

情况2:没有死锁的情况

-----准备消费50,当前剩余30,暂不能消费!
已经消费了30个产品,现仓储量为0
-----准备消费50,当前剩余0,暂不能消费!
已经生产了10个产品,现仓储量为10
已经生产了80个产品,现仓储量为90
已经生产了10个产品,现仓储量为100
------要生产的产品数量10超过剩余库存量0,暂时不能执行生产任务!
------要生产的产品数量10超过剩余库存量0,暂时不能执行生产任务!
------要生产的产品数量10超过剩余库存量0,暂时不能执行生产任务!
------要生产的产品数量10超过剩余库存量0,暂时不能执行生产任务!
已经消费了20个产品,现仓储量为80
已经生产了10个产品,现仓储量为90
已经生产了10个产品,现仓储量为100
------要生产的产品数量10超过剩余库存量0,暂时不能执行生产任务!
------要生产的产品数量10超过剩余库存量0,暂时不能执行生产任务!
已经消费了50个产品,现仓储量为50
已经生产了10个产品,现仓储量为60
已经生产了10个产品,现仓储量为70

上面代码中标黄的两个while能否换成 if 呢?如果我们换成if,可能得到如下的结果:

已经消费了20个产品,现仓储量为10
已经生产了10个产品,现仓储量为20
已经生产了10个产品,现仓储量为30
已经生产了10个产品,现仓储量为40
------要生产的产品数量80超过剩余库存量60,暂时不能执行生产任务!
-----准备消费50,当前剩余40,暂不能消费!
已经消费了30个产品,现仓储量为10
已经生产了10个产品,现仓储量为20
已经消费了50个产品,现仓储量为-30
已经生产了10个产品,现仓储量为-20
已经生产了80个产品,现仓储量为60
已经生产了10个产品,现仓储量为70

显然,换成if后,可能会出现非预期的效果,通过这个比较,我们可以发现,线程调用wait()又被唤醒后,是会继续执行wait()之后的代码的。

而我们的业务要求是,当前的生产数量一定不能大于剩余库存  且  当前准备消费的数量 一定不能小于库存,所以当线程被唤醒后,需要再次做出库存的校验,所以代码中的while一定不能换成if。

还有一个问题,为什么执行的时候,有时会出现死锁的情况呢?(出现死锁时,我们可以发现eclipse的控制台上的运行的红色按钮始终没有熄灭,说明程序还没有执行完,这时,不管过多久程序都不会结束了,因为,程序死锁了)

我们分析一下最后输出的日志:

------要生产的产品数量80超过剩余库存量60,暂时不能执行生产任务!
-----准备消费50,当前剩余40,暂不能消费!

我们可以看出,当producer线程准备去生产的时候,发现剩余库存不足,所以它调用wait(),放弃了对象锁(这里的对象锁为Producer的实例p7),处于等待状态。

而此时consumer线程准备去消费的时候,发现库存不足,不能消费,所以它调用wait(),放弃对象锁(c1),处于等待状态。

这两个线程相互等待,最终也没有线程去唤醒它们,所以出现了死锁。

最后再贴一个死锁的代码:

/**
 * Java线程:并发协作-死锁
 *
 */
public class Test {
    public static void main(String[] args) {
        DeadlockRisk dead = new DeadlockRisk();
        MyThread t1 = new MyThread(dead, 1, 2);
        MyThread t2 = new MyThread(dead, 3, 4);
        MyThread t3 = new MyThread(dead, 5, 6);
        MyThread t4 = new MyThread(dead, 7, 8);

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

}

class MyThread extends Thread {
    private DeadlockRisk dead;
    private int a, b;

    MyThread(DeadlockRisk dead, int a, int b) {
        this.dead = dead;
        this.a = a;
        this.b = b;
    }

    @Override
    public void run() {
        dead.read();
        dead.write(a, b);
    }
}

class DeadlockRisk {
    private static class Resource {
        public int value;
    }

    private Resource resourceA = new Resource();
    private Resource resourceB = new Resource();

    public int read() {
        synchronized (resourceA) {
            System.out.println("read():" + Thread.currentThread().getName() + "获取了resourceA的锁!");
            synchronized (resourceB) {
                System.out.println("read():" + Thread.currentThread().getName() + "获取了resourceB的锁!");
                return resourceB.value + resourceA.value;
            }
        }
    }

    public void write(int a, int b) {
        synchronized (resourceB) {
            System.out.println("write():" + Thread.currentThread().getName() + "获取了resourceA的锁!");
            synchronized (resourceA) {
                System.out.println("write():" + Thread.currentThread().getName() + "获取了resourceB的锁!");
                resourceA.value = a;
                resourceB.value = b;
            }
        }
    }
}

并非每次执行都会死锁,要多试几次。

线程发生死锁可能性很小,即使看似可能发生死锁的代码,在运行时发生死锁的可能性也是小之又小。

发生死锁的原因一般是两个对象的锁相互等待造成的。

上面的代码出现死锁时控制台如下:

时间: 2024-11-07 23:54:33

并发协作:多线程中的生产者与消费者模型的相关文章

java多线程中的生产者与消费者之等待唤醒机制@Version1.0

一.生产者消费者模式的学生类成员变量生产与消费demo,第一版1.等待唤醒:    Object类中提供了三个方法:    wait():等待    notify():唤醒单个线程    notifyAll():唤醒所有线程2.为什么这些方法不定义在Thread类中呢?  这些方法的调用必须通过锁对象调用,而我们刚才使用的锁对象是任意锁对象.  所以,这些方法必须定义在Object类中.3.当我们在使用多线程的时候有的时候需要,一条线程产生一个数据,另一条线程接着消费一个数据,一边生产一边消费,

java多线程中的生产者与消费者之等待唤醒机制@Version2.0

二.生产者消费者模式的学生类成员变量生产与消费demo, @Version2.0 在学生类中添加同步方法:synchronized get()消费者,synchronized set()生产者 最终版的代码中: 把student的成员变量给私有化了, 把设置和获取的功能给封装成了功能,并加了同步, 设置或者获取的线程里面只需要调用方法即可. 1.等待唤醒:    Object类中提供了三个方法:    wait():等待    notify():唤醒单个线程    notifyAll():唤醒所

Java多线程的生产者与消费者模型,线程间的通信

java多线程中的生产者与消费者模式:首先有一个阻塞队列,生产者将生产的东西放到队列里,消费者再从队列中取.当队列中的东西数量达到其容量就发生阻塞. import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import jav

Java并发协作——生产者、消费者模型

概述 对于多线程程序来说,生产者和消费者模型是非常经典的模型.更加准确的说,应该叫"生产者-消费者-仓库模型".离开了仓库,生产者.消费者就缺少了共用的存储空间,也就不存在并非协作的问题了. 示例 定义一个场景.一个仓库只允许存放10件商品,生产者每次可以向其中放入一个商品,消费者可以每次从其中取出一个商品.同时,需要注意以下4点: 1.  同一时间内只能有一个生产者生产,生产方法需要加锁synchronized. 2.  同一时间内只能有一个消费者消费,消费方法需要加锁synchro

多线程中的生产者消费者Java源代码(带注释)

同步解决了线程中数据存取不一致的问题,而Object类中的等待与唤醒方法解决了重复存取的问题 以下的生产者消费者Java源代码例子,很好的说明了这一点. 其中包括Info类.Producter类.Consumer类.Test类. <1> Info类如下: 1 package per.producterconsumer; 2 3 public class Info { 4 5 private boolean flag = true; 6 /* 7 * flag=true 表示此时可以生产,但不能

Java中的生产者、消费者问题

Java中的生产者.消费者问题描述: 生产者-消费者(producer-consumer)问题, 也称作有界缓冲区(bounded-buffer)问题, 两个进程共享一个公共的固定大小的缓冲区(仓库). 其中一个是生产者, 用于将产品放入仓库: 另外一个是消费者, 用于从仓库中取出产品消费. 问题出现在当仓库已经满了, 而此时生产者还想向其中放入一个新的产品的情形, 其解决方法是让生产者此时进行等待, 等待消费者从仓库中取走了一个或者多个产品后再去唤醒它. 同样地, 当仓库已经空了, 而消费者还

并发无锁队列学习(单生产者单消费者模型)

1.引言 本文介绍单生产者单消费者模型的队列.根据写入队列的内容是定长还是变长,分为单生产者单消费者定长队列和单生产者单消费者变长队列两种.单生产者单消费者模型的队列操作过程是不需要进行加锁的.生产者通过写索引控制入队操作,消费者通过读索引控制出队列操作.二者相互之间对索引是独享,不存在竞争关系.如下图所示: 2.单生产者单消费者定长队列 这种队列要求每次入队和出队的内容是定长的,即生产者写入队列和消费者读取队列的内容大小事相同的.linux内核中的kfifo就是这种队列,提供了读和写两个索引.

单生产者-多消费者模型中遇到的问题

(1)      原始代码 最近使用单生产者-多消费者模型是遇到一个问题,以前既然都没有想到过.生产者线程的代码如下,基本功能就是接收到一个连接之后创建一个Socket对象并放到list中等待处理. void DataManager::InternalStart() { server_socket_ = new ServerSocket(); if (!server_socket_->SetAddress(NetworkUtil::GetIpAddress().c_str(), 9091)) {

生产者、消费者模型

转载地址:http://blog.csdn.net/snow_5288/article/details/72794306 一.概念引入 日常生活中,每当我们缺少某些生活用品时,我们都会去超市进行购买,那么,你有没有想过,你是以什么身份去的超市呢?相信大部分人都会说自己是消费者,确实如此,那么既然我们是消费者,又是谁替我们生产各种各样的商品呢?当然是超市的各大供货商,自然而然地也就成了我们的生产者.如此一来,生产者有了,消费者也有了,那么将二者联系起来的超市又该作何理解呢?诚然,它本身是作为一座交