[Java基础] java多线程关于消费者和生产者

简介:
多线程: 生产与消费

1.生产者Producer生产produce产品,并将产品放到库存inventory里;同时消费者Consumer从库存inventory里消费consume产品。

2.库存inventory的总量(最大库存量100)是有限的。如果库存inventory满了,生产者不能在库存inventory继续生产produce产品,须等待状态。等待产品被消费者Consumer消费consume了,再往库存inventory生产produce产品。

3.若库存inventory空了,消费者Consumer也须等待状态。等待生产者生产produce产品,再将消费者Consumer唤醒进行消费consume。

补充要求:需要6个线程,分别实现
1.库存为0;2.消费1消费10个(但库存零,则需等待);3.生产2生产5个;4.生产3生产5个(此时库存有10个,则满足消费1的消费;)最终库存仍有0个;5.生产4生产100个);6.生产5生产10个(因库存满了,无法生产,需等待)

复制代码
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
 
public class BlockingQueueTest {
 public static void main(String[] args) {
  ExecutorService service = Executors.newCachedThreadPool();
  BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>(100);
  System.out.println("blockingQueue now contains "  + blockingQueue.size() + " unit");
  service.submit(new Consumer1(blockingQueue));
  gap(blockingQueue);
  service.submit(new Productor2(blockingQueue));
  gap(blockingQueue);
  service.submit(new Productor3(blockingQueue));
  gap(blockingQueue);
  service.submit(new Productor4(blockingQueue));
  gap(blockingQueue);
  service.submit(new Productor5(blockingQueue));
  gap(blockingQueue);
   
  service.shutdown();
 }
 private static void gap(BlockingQueue<String> blockingQueue) {
  try {
   Thread.sleep(1000);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  System.out.println("blockingQueue now contains "  + blockingQueue.size() + " unit");
 }
}
class Consumer1 implements Runnable{
 BlockingQueue<String> blockingQueue;
  
 public Consumer1(BlockingQueue<String> blockingQueue) {
  super();
  this.blockingQueue = blockingQueue;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  System.out.println("Consumer1 start: need 10 units");
  for(int i = 0; i < 10; i++){
   try {
    blockingQueue.take();
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  System.out.println("Consumer1 end: has got 10 units");
 }
  
}
class Productor2 implements Runnable{
 BlockingQueue<String> blockingQueue;
  
 public Productor2(BlockingQueue<String> blockingQueue) {
  super();
  this.blockingQueue = blockingQueue;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  System.out.println("Productor2 start: put 5 units");
  for(int i = 0; i < 5; i++){
   try {
    blockingQueue.put("Object");
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  System.out.println("Productor2 end: has put 5 units");
 }
  
}
class Productor3 implements Runnable{
 BlockingQueue<String> blockingQueue;
  
 public Productor3(BlockingQueue<String> blockingQueue) {
  super();
  this.blockingQueue = blockingQueue;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  System.out.println("Productor3 start: put 5 units");
  for(int i = 0; i < 5; i++){
   try {
    blockingQueue.put("Object");
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  System.out.println("Productor3 end: has put 5 units");
 }
  
}
class Productor4 implements Runnable{
 BlockingQueue<String> blockingQueue;
  
 public Productor4(BlockingQueue<String> blockingQueue) {
  super();
  this.blockingQueue = blockingQueue;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  System.out.println("Productor4 start: put 100 units");
  for(int i = 0; i < 100; i++){
   try {
    blockingQueue.put("Object");
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  System.out.println("Productor4 end: has put 100 units");
 }
  
}
class Productor5 implements Runnable{
 BlockingQueue<String> blockingQueue;
  
 public Productor5(BlockingQueue<String> blockingQueue) {
  super();
  this.blockingQueue = blockingQueue;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  System.out.println("Productor5 start: put 10 units");
  for(int i = 0; i < 100; i++){
   try {
    blockingQueue.put("Object");
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  System.out.println("Productor5 end: has put 10 units");
 }
  
}
复制代码

每个线程是隔了1s启动的, 结果

blockingQueue now contains 0 unit
Consumer1 start: need 10 units
blockingQueue now contains 0 unit
Productor2 start: put 5 units
Productor2 end: has put 5 units
blockingQueue now contains 0 unit
Productor3 start: put 5 units
Productor3 end: has put 5 units
Consumer1 end: has got 10 units
blockingQueue now contains 0 unit
Productor4 start: put 100 units
Productor4 end: has put 100 units
blockingQueue now contains 100 unit
Productor5 start: put 10 units
blockingQueue now contains 100 unit





分类:  Java基础
本文转自demoblog博客园博客,原文链接http://www.cnblogs.com/0616--ataozhijia/p/4126164.html如需转载请自行联系原作者

demoblog
相关文章
|
3月前
|
安全 算法 Java
Java 多线程:线程安全与同步控制的深度解析
本文介绍了 Java 多线程开发的关键技术,涵盖线程的创建与启动、线程安全问题及其解决方案,包括 synchronized 关键字、原子类和线程间通信机制。通过示例代码讲解了多线程编程中的常见问题与优化方法,帮助开发者提升程序性能与稳定性。
161 0
|
7月前
|
Java 开发者
重学Java基础篇—Java类加载顺序深度解析
本文全面解析Java类的生命周期与加载顺序,涵盖从加载到卸载的七个阶段,并深入探讨初始化阶段的执行规则。通过单类、继承体系的实例分析,明确静态与实例初始化的顺序。同时,列举六种触发初始化的场景及特殊场景处理(如接口初始化)。提供类加载完整流程图与记忆口诀,助于理解复杂初始化逻辑。此外,针对空指针异常等问题提出排查方案,并给出最佳实践建议,帮助开发者优化程序设计、定位BUG及理解框架机制。最后扩展讲解类加载器层次与双亲委派机制,为深入研究奠定基础。
259 0
|
3月前
|
存储 Java 程序员
Java 基础知识点全面梳理包含核心要点及难点解析 Java 基础知识点
本文档系统梳理了Java基础知识点,涵盖核心特性、语法基础、面向对象编程、数组字符串、集合框架、异常处理及应用实例,帮助初学者全面掌握Java入门知识,提升编程实践能力。附示例代码下载链接。
159 1
|
5月前
|
IDE Java 开发工具
【Java基础-环境搭建-创建项目】IntelliJ IDEA创建Java项目的详细步骤
IntelliJ IDEA创建Java项目的图文详细步骤,手把手带你创建Java项目
898 10
【Java基础-环境搭建-创建项目】IntelliJ IDEA创建Java项目的详细步骤
|
4月前
|
存储 安全 Java
2025 年最新 40 个 Java 基础核心知识点全面梳理一文掌握 Java 基础关键概念
本文系统梳理了Java编程的40个核心知识点,涵盖基础语法、面向对象、集合框架、异常处理、多线程、IO流、反射机制等关键领域。重点包括:JVM运行原理、基本数据类型、封装/继承/多态三大特性、集合类对比(ArrayList vs LinkedList、HashMap vs TreeMap)、异常分类及处理方式、线程创建与同步机制、IO流体系结构以及反射的应用场景。这些基础知识是Java开发的根基,掌握后能为后续框架学习和项目开发奠定坚实基础。文中还提供了代码资源获取方式,方便读者进一步实践学习。
1197 2
|
4月前
|
存储 安全 Java
Java 基础知识面试题汇总 最全面的 Java 基础面试题整理
本文全面解析Java基础知识面试题,涵盖Java基础概念、面向对象编程、异常处理、集合框架等核心内容。通过实际应用场景,提供技术方案与应用实例,如JDK与JRE区别、==与equals()差异、String类特性、final与static关键字用法、多继承替代方案及接口与抽象类对比。帮助开发者夯实基础,高效备考,提升实战能力。附带完整代码示例,可供下载学习。
636 3
|
4月前
|
Java 数据挖掘 调度
Java 多线程创建零基础入门新手指南:从零开始全面学习多线程创建方法
本文从零基础角度出发,深入浅出地讲解Java多线程的创建方式。内容涵盖继承`Thread`类、实现`Runnable`接口、使用`Callable`和`Future`接口以及线程池的创建与管理等核心知识点。通过代码示例与应用场景分析,帮助读者理解每种方式的特点及适用场景,理论结合实践,轻松掌握Java多线程编程 essentials。
300 5
|
4月前
|
监控 搜索推荐 Java
Java 多线程最新实操技术与应用场景全解析:从基础到进阶
本文深入探讨了Java多线程的现代并发编程技术,涵盖Java 8+新特性,如CompletableFuture异步处理、Stream并行流操作,以及Reactive编程中的Reactor框架。通过具体代码示例,讲解了异步任务组合、并行流优化及响应式编程的核心概念(Flux与Mono)。同时对比了同步、CompletableFuture和Reactor三种实现方式的性能,并总结了最佳实践,帮助开发者构建高效、扩展性强的应用。资源地址:[点击下载](https://pan.quark.cn/s/14fcf913bae6)。
317 3
|
5月前
|
算法 Java 调度
Java多线程基础
本文主要讲解多线程相关知识,分为两部分。第一部分涵盖多线程概念(并发与并行、进程与线程)、Java程序运行原理(JVM启动多线程特性)、实现多线程的两种方式(继承Thread类与实现Runnable接口)及其区别。第二部分涉及线程同步(同步锁的应用场景与代码示例)及线程间通信(wait()与notify()方法的使用)。通过多个Demo代码实例,深入浅出地解析多线程的核心知识点,帮助读者掌握其实现与应用技巧。
117 1
|
5月前
|
Java
java 多线程异常处理
本文介绍了Java中ThreadGroup的异常处理机制,重点讲解UncaughtExceptionHandler的使用。通过示例代码展示了当线程的run()方法抛出未捕获异常时,JVM如何依次查找并调用线程的异常处理器、线程组的uncaughtException方法或默认异常处理器。文章还提供了具体代码和输出结果,帮助理解不同处理器的优先级与执行逻辑。
136 1