生产者和消费者的经典问题 java编程实现

最新推荐文章于 2024-07-10 09:44:18 发布
最新推荐文章于 2024-07-10 09:44:18 发布
阅读量1k 收藏 1
点赞数
分类专栏： java

1、使用synchronized

import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
* synchronized实现的生产者和消费者
*/
public class ProducerCustomerWithSynchronized {

Executor pool = Executors.newFixedThreadPool(10);

//仓库
private List<String> storageList = new LinkedList<String>();

//仓库容量
private int MAX_SIZE = 3;

//仓库为空
private int ZERO = 0;

//生产者线程
private class Producer implements Runnable{

    //生产方法，需同步
    private void produce(){
        synchronized (storageList) {
            System.out.println(Thread.currentThread().getName()+"进入仓库，准备生产！");
            try {
                if(storageList.size()==MAX_SIZE) {
                    System.out.println("仓库已满！等待消费者消费");
                    Thread.sleep(1000);
                    storageList.wait();//当前线程放弃锁，处于等待状态，让其他线程执行
                }
                if(storageList.size()<MAX_SIZE) {
                    String name = "产品"+new Random().nextInt();
                    storageList.add(name);
                    System.out.println(Thread.currentThread().getName()+"往仓库中生产了一个产品！");
                }
                Thread.sleep(1000);
                storageList.notifyAll();//当前线程放弃锁，唤醒其他线程

            }catch(InterruptedException ie) {
                System.out.println("中断异常");
                ie.printStackTrace();
            }

        }
    }

    @Override
    public void run() {
        while(true) {
            produce();
        }
    }
}

//消费者线程
private class Customer implements Runnable{

    //消费方法，需同步
    private void consume() {
        synchronized (storageList) {
            System.out.println(Thread.currentThread().getName()+"进入仓库，准备消费！");
            try {
                if(storageList.size()==ZERO) {
                    System.out.println("仓库已空！等待生产者生产");
                    Thread.sleep(1000);
                    storageList.wait();//当前线程放弃锁，处于等待状态，让其他线程执行
                }
                if(storageList.size()!=ZERO) {
                    System.out.println(Thread.currentThread().getName()+"从仓库取得产品："+storageList.remove(0));
                }
                Thread.sleep(1000);
                storageList.notifyAll();//当前线程放弃锁，唤醒其他线程
            }catch(InterruptedException ie) {
                System.out.println("中断异常");
                ie.printStackTrace();
            }

        }
    }

    @Override
    public void run() {
        while(true) {
            consume();
        }
    }

}

//启动生产者和消费者线程
public void start() {
    for(int i=1;i<5;i++) {
        //new Thread(new Producer()).start();
        //new Thread(new Customer()).start();
        pool.execute(new Producer());
        pool.execute(new Customer());
    }

}

public static void main(String[] args) {
    ProducerCustomerWithSynchronized pc = new ProducerCustomerWithSynchronized();
    pc.start();
}

}

2.使用Lock

import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
* Lock实现的生产者和消费者
*
*/
public class ProducerCustomerWithLock {

Executor pool = Executors.newFixedThreadPool(10);

//仓库
private List<String> storageList = new LinkedList<String>();

//仓库容量
private int MAX_SIZE = 3;

//仓库为空
private int ZERO = 0;

//获取锁对象
private Lock lock = new ReentrantLock();

//仓库满了，绑定生产者线程
private Condition full = lock.newCondition();

//仓库为空，绑定消费者线程
private Condition empty = lock.newCondition();

//生产者线程
private class Producer implements Runnable{

    //生产方法，需同步
    private void produce(){
        if(lock.tryLock()) {
            System.out.println(Thread.currentThread().getName()+"进入仓库，准备生产！");
            try {
                if(storageList.size()==MAX_SIZE) {
                    System.out.println("仓库已满！等待消费者消费");
                    Thread.sleep(1000);
                    full.await();//生产者线程加入线程等待池
                }
                if(storageList.size()<MAX_SIZE){
                    String name = "产品"+new Random().nextInt();
                    storageList.add(name);
                    System.out.println(Thread.currentThread().getName()+"往仓库中生产了一个产品！");
                }
                Thread.sleep(1000);
                empty.signalAll();//唤醒消费者线程

            }catch(InterruptedException ie) {
                System.out.println("中断异常");
                ie.printStackTrace();
            }finally{
                lock.unlock();
            }
        }
    }

    @Override
    public void run() {
        while(true) {
            produce();
        }
    }
}

//消费者线程
private class Customer implements Runnable{

    //消费方法，需同步
    private void consume() {
        if(lock.tryLock()) {
            System.out.println(Thread.currentThread().getName()+"进入仓库，准备消费！");
            try {
                if(storageList.size()==ZERO) {
                    System.out.println("仓库已空！等待生产者生产");
                    Thread.sleep(1000);
                    empty.await();//消费者线程加入线程等待池
                }
                if(storageList.size()!=ZERO) {
                    System.out.println(Thread.currentThread().getName()+"从仓库取得产品："+storageList.remove(0));
                }

                Thread.sleep(1000);
                full.signalAll();//唤醒生产者线程
            }catch(InterruptedException ie) {
                System.out.println("中断异常");
                ie.printStackTrace();
            }finally{
                lock.unlock();
            }
        }
    }

    @Override
    public void run() {
        while(true) {
            consume();
        }
    }

}

//启动生产者和消费者线程
public void start() {
    for(int i=1;i<5;i++) {
        //new Thread(new Producer()).start();
        //new Thread(new Customer()).start();
        pool.execute(new Producer());
        pool.execute(new Customer());
    }

}

public static void main(String[] args) {
    ProducerCustomerWithLock pc = new ProducerCustomerWithLock();
    pc.start();
}

}
3.BlockingQueue实现的生产者和消费者
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
* BlockingQueue实现的生产者和消费者
*
*/
public class ProducerCustomerWithBlockingQueue {

Executor pool = Executors.newFixedThreadPool(10);

//仓库
private BlockingQueue<String> storageQueue = new LinkedBlockingQueue<String>(5);

//仓库容量
private int MAX_SIZE = 3;

//仓库为空
private int ZERO = 0;



//生产者线程
private class Producer implements Runnable{

    //生产方法，需同步
    private void produce(){
        try {
            System.out.println(Thread.currentThread().getName()+"进入仓库，准备生产！");
            if(storageQueue.size()==MAX_SIZE) {
                System.out.println("仓库已满！等待消费者消费");
                Thread.sleep(1000);
            }
            if(storageQueue.size()<=MAX_SIZE) {
                String product = "产品"+new Random().nextInt();
                storageQueue.put(product);
                System.out.println(Thread.currentThread().getName()+"往仓库中生产了一个产品！");
            }
            Thread.sleep(1000);
        }catch(InterruptedException ie) {
            System.out.println("中断异常");
            ie.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true) {
            produce();
        }
    }
}

//消费者线程
private class Customer implements Runnable{

    //消费方法，需同步
    private void consume() {
        try {
            System.out.println(Thread.currentThread().getName()+"进入仓库，准备消费！");
            if(storageQueue.size()==ZERO) {
                System.out.println("仓库已空！等待生产者生产");
                Thread.sleep(1000);
            }
            if(storageQueue.size()!=ZERO) {
                System.out.println(Thread.currentThread().getName()+"从仓库取得产品："+storageQueue.take());
            }
            Thread.sleep(1000);
        }catch(InterruptedException ie) {
            System.out.println("中断异常");
            ie.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true) {
            consume();
        }
    }

}

//启动生产者和消费者线程
public void start() {
    for(int i=1;i<5;i++) {
        //new Thread(new Producer()).start();
        ///new Thread(new Customer()).start();
        pool.execute(new Producer());
        pool.execute(new Customer());
    }

}

public static void main(String[] args) {
    ProducerCustomerWithBlockingQueue pc = new ProducerCustomerWithBlockingQueue();
    pc.start();
}

}

饭小粒
关注
专栏目录
生产者和消费者问题的Java实现
no pains,no gains!
04-13 477
1.要理解生产消费者问题，首先应弄清PV操作的含义：PV操作是由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下： P（S）：①将信号量S的值减1，即S=S-1； ②如果S³0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。 V（S）：①将信号量S的值加1，即S=S+1； ②如果S>0，则该进
生产者-消费者问题 java实现
喜欢讨论、分享
06-29 1378
一、明确定义 要理解生产消费者问题，首先应弄清PV操作的含义：PV操作是由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下：     P（S）：①将信号量S的值减1，即S=S-1；             ②如果S³0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。     V（S）：①将信号量S的值加1，即S=S+1；
多线程代码 经典线程同步互斥问题 生产者消费者问题
06-01
a: 创建一个线程 b: 创建多个线程 c: 多线程访问同一资源 d: 经典线程同步互斥问题 e: 使用关键段解决子线程互斥问题 f: 利用事件实现线程同步问题 g: 利用互斥量来解决线程同步互斥问题 h: problem1 生产者消费者问题 (1生产者 1消费者 1缓冲区) problem1 more 生产者消费者问题 (1生产者 2消费者 4缓冲区) problem2 读者与写着问题 I: 信号量 semaphore 解决线程同步问题
java模拟实现生产者---消费者问题
weixin_34268610的博客
01-29 279
本文章为小编原创，请尊重文章的原创性，转载请注意写明转载来源：http://blog.csdn.net/u012116457 已知技术參数： 生产者消费者问题，描写叙述一组生产者向一组消费者提供产品/消息。它们共享一个有界缓冲区，生产者向当中放产品/消息，消费者从中取产品/消息。仅仅要缓冲区未满，生产者可放产品/消息，仅仅要缓冲区有数据。消费者可取消息。即应满足下列二个同步条件...
【转】-Java实现生产者和消费者的5种方式
最新发布
booleandev
07-10 1211
生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。现在用四种方式来实现生产者消费者模型。
实验3：生产者消费者问题实践（编程实验）
qq_62791684的博客
10-24 5854
生产者消费者问题实践（编程实验）
消费者与生产者的问题（java）--经典案列
可行的code
03-26 261
消费者与生产者的问题是计算机中常见的问题，是在java多线程经典问题 1.java多线程实现 wait() / notify()方法 wait() / nofity()方法是基类Object的两个方法： wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。 notify()方法：当生产者/消费者向缓冲区放入/取出一个...
经典问题生产者与消费者java并发线程模拟实现
FzuGsr的专栏
09-19 447
生产者与消费者问题是操作系统中一个基础的问题。大致描述如下：生产者生产产品，消费者消费该产品。生产者只有等待消费者将产品消费完之后才能继续生产下一个产品，而消费者只有等带生产者生产完才能进行消费。生产者依赖于消费者，消费者依赖于生产者。 将该问题放到Java中来实现就是一个并发的多线程的问题，为了保证数据的完整性，需要借助线程同步的synchronized，用于控制数据同步时的一致。 同时为了保
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费者之间的协作关系。在这个模型中，生产者...
Java——生产者-消费者问题
12-21
总结来说，这个Java程序通过使用信号量和多线程技术，生动地演示了解决"生产者-消费者"问题的过程。它不仅展示了如何在Java中实现线程同步，还通过图形界面和随机休眠策略来模拟现实生活中的并发挑战，这对于理解和...
Java实现简易生产者消费者模型过程解析
08-19
生产者消费者模型是一种常见的并发编程模型，在Java中可以通过使用同步机制和wait/notify机制来实现。在本文中，我们将通过一个简单的示例代码介绍Java实现简易生产者消费者模型的过程。 二、Java实现生产者消费者...
操作系统上机实验报告 进程同步和通信-生产者和消费者问题模拟
07-18
1. 目的： 调试、修改、运行模拟程序，通过形象化的状态显示，使学生理解进程的概念，了解同步和通信的过程，掌握进程通信和同步的机制，特别是利用缓冲区进行同步和通信的过程。通过补充新功能，使学生能灵活运用相关知识，培养创新能力。 2. 内容及要求： 1) 调试、运行模拟程序。 2) 发现并修改程序中不完善的地方。 3) 修改程序，使用随机数控制创建生产者和消费者的过程。 4) 在原来程序的基础上，加入缓冲区的写互斥控制功能，模拟多个进程存取一个公共缓冲区，当有进程正在写缓冲区时，其他要访问该缓冲区的进程必须等待，当有进程正在读取缓冲区时，其他要求读取的进程可以访问，而要求写的进程应该等待。 5) 完成1)、2)、3）功能的,得基本分,完成4)功能的加2分,有其它功能改进的再加2分 3. 程序说明： 　　本程序是模拟两个进程，生产者（producer）和消费者(Consumer)工作。生产者每次产生一个数据，送入缓冲区中。消费者每次从缓冲区中取走一个数据。缓冲区可以容纳8个数据。因为缓冲区是有限的，因此当其满了时生产者进程应该等待，而空时，消费者进程应该等待；当生产者向缓冲区放入了一个数据，应唤醒正在等待的消费者进程，同样，当消费者取走一个数据后，应唤醒正在等待的生产者进程。就是生产者和消费者之间的同步。 　　每次写入和读出数据时，都将读和写指针加一。当读写指针同样时，又一起退回起点。当写指针指向最后时，生产者就等待。当读指针为零时，再次要读取的消费者也应该等待。 为简单起见，每次产生的数据为0-99的整数，从0开始，顺序递增。两个进程的调度是通过运行者使用键盘来实现的。 4. 程序使用的数据结构 进程控制块：包括进程名，进程状态和执行次数。 缓冲区：一个整数数组。 缓冲区说明块：包括类型，读指针，写指针，读等待指针和写等待指针。 5. 程序使用说明 　　启动程序后，如果使用'p'键则运行一次生产者进程，使用'c'键则运行一次消费者进程。通过屏幕可以观察到两个进程的状态和缓冲区变化的情况。
java生产者消费者问题 实验报告
12-29
java实现生产者消费者问题，实验报告，很好的参考材料
java生产者与消费者实验报告
07-26
java生成者与消费者实验报告内含封面代码和截图
实现生产者消费者问题_实验报告
07-09
1.内涵代码，是操作系统课程作业，程序简单易于理解 2.由于代码写在报告中，故类的import项目没有写入，需运行时在程序中自行添加
Java实现Kafka生产者消费者代码实例
08-19
在当今大数据时代背景下，消息队列服务在各种系统架构中扮演着非常重要的角色，尤其是在...上述代码片段虽然简单，但它涵盖了Kafka生产者消费者模型的基本实现原理，为理解和开发更复杂的Kafka应用程序打下了基础。
java生产者消费者问题代码实现
12-25
Java 生产者消费者问题是计算机科学中的一种经典同步问题，它描述了多个生产者和消费者之间的关系，生产者负责生产数据，而消费者负责消费数据。在解决这个问题时，需要使用同步机制来确保生产者和消费者之间的正确...
生产者消费者问题（java模拟）
zhujiaxing666666的专栏
07-18 974
import java.util.Stack; import java.util.concurrent.atomic.AtomicInteger; /** * 1个生产者 3个消费者 生产、消费10次 * * @作者 pt * */ public class ProducerConsumer { StackInteger> items =
Java多线程生产者消费者问题实现与示例
在JAVA作业二——生产者消费者问题中，学生们被要求实现一个多线程环境下的生产者-消费者模型。该模型的关键在于设计两个独立的线程，生产者负责生产数据（商品），而消费者负责消费这些数据。以下是核心知识点的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值