栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java多线程实现生产者消费者(简易版)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java多线程实现生产者消费者(简易版)

生产者消费者问题

生产者消费者问题是一个多线程同步的问题。
1.生产者生产一定数量的数据放到缓冲区,然后继续生产
2.消费者在缓冲区中消耗这些数据
!!!要保证生产者在缓冲区满时存放数据
!!!要保证消费者在缓冲区空时消耗数据

具体实现

1.采用信号
2.加锁机制

这里用wait() / notify()方法实现
- 当缓冲区满的时候,生产者停止执行,让其他线程进行
- 当缓冲区空的时候,消费者停止执行,让其他线程执行
- 当生产者向缓冲区放入一个产品时,向其他等待的线程发出可执行的通知,同时放弃锁,使自己处于等待状态;
- 当消费者从缓冲区取出一个产品时,向其他等待的线程发出可执行的通知,同时放弃锁,使自己处于等待状态。
仓库Storage
package producer;

import java.util.LinkedList;

public class Storage {
    //仓库容量
    private final int MAX_SIZE = 10;
    //仓库存储的载体
    private LinkedList list= new LinkedList<>();
    //生产方法
    public void produce(){
        synchronized (list){
            //判断仓库是否满,满则进入wait阶段
            while (list.size()+1 >MAX_SIZE){
                System.out.println("生产者"+Thread.currentThread().getName()+"仓库已经满了");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //没有满则可以生产
            list.add(new Object());
            System.out.println("生产者"+Thread.currentThread().getName()+"生产了一个产品,现在库存有"+list.size());
            list.notifyAll();
        }
    }
    //消费方法
    public void consume(){
        synchronized (list){
            //当库存为0则不让消费
            while (list.size()==0){
                System.out.println("消费者是"+Thread.currentThread().getName()+"仓库容量为空");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //不是空则可以消费
            list.remove();
            System.out.println("消费者"+Thread.currentThread().getName()+"消费了一个产品,现在还剩有产品"+list.size());
            list.notifyAll();
        }
    }

}

 
生产者 
package producer;

public class Producer implements Runnable{
    //生产者类
    private Storage storage;
    public Producer(){

    }
    public Producer(Storage storage){
        this.storage = storage;
    }
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(1000);
                storage.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者
package producer;

public class Consumer implements Runnable{
    //消费者
    private Storage storage;
    public Consumer(){

    }
    public Consumer(Storage storage){
        this.storage = storage;
    }
    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(3000);
                storage.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

主方法
package producer;

public class Main {
    public static void main(String[] args) {
        Storage storage = new Storage();
        Thread p1 = new Thread(new Producer(storage));
        Thread p2 = new Thread(new Producer(storage));
        Thread p3 = new Thread(new Producer(storage));

        Thread c1 = new Thread(new Consumer(storage));
        Thread c2 = new Thread(new Consumer(storage));
        Thread c3 = new Thread(new Consumer(storage));

        p1.start();
        p2.start();
        p3.start();
        c1.start();
        c2.start();
        c3.start();
    }
}

运行结果


一个生产者线程运行produce方法,睡眠1s;一个消费者运行一次consume方法,睡眠3s。

notifyAll()方法可使所有正在等待队列中等待同一共享资源的“全部”线程从等待状态退出,进入可运行状态。此时,优先级最高的哪个线程最先执行,但也有可能是随机执行的,这要取决于JVM虚拟机的实现。

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号