[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多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
3天前
|
Java
JAVA多线程通信:为何wait()与notify()如此重要?
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件满足时被唤醒,从而确保数据一致性和同步。相比其他通信方式,如忙等待,这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
11 3
|
1天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
2天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
10 1
|
3天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中,多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程,以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发,逐步探索线程池的高效使用,并讨论常见的多线程问题。无论你是Java新手还是希望深化理解,这篇文章都将为你打开多线程的大门。
|
3月前
|
存储 监控 Java
Java多线程优化:提高线程池性能的技巧与实践
Java多线程优化:提高线程池性能的技巧与实践
110 1
|
6月前
|
设计模式 监控 Java
Java多线程基础-11:工厂模式及代码案例之线程池(一)
本文介绍了Java并发框架中的线程池工具,特别是`java.util.concurrent`包中的`Executors`和`ThreadPoolExecutor`类。线程池通过预先创建并管理一组线程,可以提高多线程任务的效率和响应速度,减少线程创建和销毁的开销。
188 2
|
6月前
|
Java 数据库
【Java多线程】对线程池的理解并模拟实现线程池
【Java多线程】对线程池的理解并模拟实现线程池
58 1
|
3月前
|
安全 算法 Java
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)(下)
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)
75 6
|
3月前
|
存储 安全 Java
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)(中)
17 Java多线程(线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合)
83 5