`
xmong
  • 浏览: 264151 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

java多线程设计模式之生产者与消费者

阅读更多


Java实现多线程生产者与消费者:

生产者线程负责生产产品,将产品保存到产品队列中,消费者负责从队列中取出产品消费。产品队列有一定的容量,当产品队列中没有产品时,消费者线程必须等待生产者线程生产产品,当产品队列中产品数量达到队列容量时,生产者等待消费者消费产品。
设计如下:
Product:产品类存储产品信息
ProductQueue:产品队列负责存储产品
ProducerThread:生产者线程负责生产产品
ConsumerThread:消费者线程负责消费产品
Main:程序入口

实现如下:
Product:产品类
package com.thread.product;

/**
 * 产品类
 * @author Administrator
 *
 */
public class Product {

	
	/**
	 * 产品名称
	 */
	private final String name;
	
	public Product(String name){
		this.name = name;
	}
	
	public String getName(){
		return name;
	}
	
	public String toString(){
		return "{product."+name+"}";
	}
	
}


ProductQueue:产品队列类

package com.thread.product;

import java.util.LinkedList;

/**
 * 产品队列类
 * @author Administrator
 *
 */
public class ProductQueue {

	/**
	 * 存储产品的队列
	 */
	private final LinkedList<Product> products = new LinkedList<Product>();
	/**
	 * 队列的容量大小
	 */
	private final int size;
	
	public ProductQueue(int size){
		this.size = size;
	}
	
	/**
	 * 向队列中添加产品,判断队列中产品大小是否达到了容量大小,
	 * 如果达到了当前生产线程等待,唤醒其他线程。
	 * 如果没有达到,当前生产线程向队列中添加产品。
	 * @param product
	 */
	public synchronized void putProduct(Product product){
		
		while(products.size() > size){//判断队列中产品是否达到队列容量
			try {
				System.out.println(Thread.currentThread().getName()+" {putProduct wait}");
				wait();//生产线程等待
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		products.addLast(product);//添加产品
		System.out.println(Thread.currentThread().getName()+" putProduct "+product);
		notifyAll();//唤醒其他等待线程
	};
	
	
	/**
	 * 获取队列中的产品,判断队列中是否存在产品,
	 * 如果没有则当前消费线程等待。
	 * 如果有则当前消费线程取出产品,唤醒其他等待线程。
	 * @return
	 */
	public synchronized Product getProduct(){
		
		while(products.size() <= 0){//判断是否队列中是否存在产品
			try {
				System.out.println(Thread.currentThread().getName()+" {getProduct wait}");
				wait();//消费线程等待
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		Product product = products.removeFirst();//取出产品
		System.out.println(Thread.currentThread().getName()+" getProduct "+product);
		notifyAll();//唤醒其他线程
		return product;
	};
	
}

ProducerThread:生产者类
package com.thread.product;

import java.util.Random;

/**
 * 生产产品线程类
 * @author Administrator
 *
 */
public class ProducerThread extends Thread{

	
	private ProductQueue productQueue;
	private Random random = new Random();
	
	public ProducerThread(String name, ProductQueue queue){
		super(name);
		this.productQueue = queue;
	}
	
	/**
	 * 循环生产产品
	 */
	public void run(){
		int count = 0;
		while(true){
			Product product = new Product("product."+count+"."+this.getName());
			productQueue.putProduct(product);
			count++;
			try {
				Thread.sleep(random.nextInt(1000));//随机休息
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}

ConsumerThread:消费者类

package com.thread.product;

import java.util.Random;


/**
 * 消费者线程类
 * @author Administrator
 *
 */
public class ConsumerThread extends Thread{

	
	private ProductQueue productQueue;
	private Random random = new Random();
	
	public ConsumerThread(String name, ProductQueue queue){
		super(name);
		this.productQueue = queue;
	}
	
	/**
	 * 循环消费产品
	 */
	public void run(){
		while(true){
			productQueue.getProduct();
			try {
				Thread.sleep(random.nextInt(1400));//随机休息
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

Main:main类

package com.thread.product;

/**
 * main类
 * @author Administrator
 *
 */
public class Main {

	/**
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		//初始化产品队列容量为5
		ProductQueue queue = new ProductQueue(5);
		//启动两个生产产品线程实例,a和b
		new ProducerThread("ProducerThread.a", queue).start();
		new ProducerThread("ProducerThread.b", queue).start();
		//启动两个消费者线程实例,a和b
		new ConsumerThread("ConsumerThread.a", queue).start();
		new ConsumerThread("ConsumerThread.b", queue).start();
	}
	
	
}


执行结果:

ProducerThread.b putProduct {product.product.0.ProducerThread.b}
ProducerThread.a putProduct {product.product.0.ProducerThread.a}
ConsumerThread.a getProduct {product.product.0.ProducerThread.b}
ConsumerThread.b getProduct {product.product.0.ProducerThread.a}
ConsumerThread.b {getProduct wait}
ProducerThread.a putProduct {product.product.1.ProducerThread.a}
ConsumerThread.b getProduct {product.product.1.ProducerThread.a}
ConsumerThread.b {getProduct wait}
ConsumerThread.a {getProduct wait}
ProducerThread.a putProduct {product.product.2.ProducerThread.a}
ConsumerThread.a getProduct {product.product.2.ProducerThread.a}
ConsumerThread.b {getProduct wait}
ConsumerThread.a {getProduct wait}
ProducerThread.b putProduct {product.product.1.ProducerThread.b}
ConsumerThread.a getProduct {product.product.1.ProducerThread.b}
ConsumerThread.b {getProduct wait}
ProducerThread.b putProduct {product.product.2.ProducerThread.b}
ConsumerThread.b getProduct {product.product.2.ProducerThread.b}
ConsumerThread.b {getProduct wait}
ProducerThread.b putProduct {product.product.3.ProducerThread.b}
ConsumerThread.b getProduct {product.product.3.ProducerThread.b}
ProducerThread.a putProduct {product.product.3.ProducerThread.a}
ProducerThread.b putProduct {product.product.4.ProducerThread.b}
ProducerThread.a putProduct {product.product.4.ProducerThread.a}
ProducerThread.a putProduct {product.product.5.ProducerThread.a}
ConsumerThread.a getProduct {product.product.3.ProducerThread.a}
ProducerThread.b putProduct {product.product.5.ProducerThread.b}
ConsumerThread.b getProduct {product.product.4.ProducerThread.b}
ConsumerThread.b getProduct {product.product.4.ProducerThread.a}
ProducerThread.a putProduct {product.product.6.ProducerThread.a}
ConsumerThread.a getProduct {product.product.5.ProducerThread.a}
ProducerThread.a putProduct {product.product.7.ProducerThread.a}
ProducerThread.b putProduct {product.product.6.ProducerThread.b}
ProducerThread.a putProduct {product.product.8.ProducerThread.a}
ProducerThread.b putProduct {product.product.7.ProducerThread.b}
ConsumerThread.b getProduct {product.product.5.ProducerThread.b}
ConsumerThread.a getProduct {product.product.6.ProducerThread.a}
ProducerThread.a putProduct {product.product.9.ProducerThread.a}
ProducerThread.b putProduct {product.product.8.ProducerThread.b}
ConsumerThread.b getProduct {product.product.7.ProducerThread.a}
ProducerThread.a putProduct {product.product.10.ProducerThread.a}
ConsumerThread.a getProduct {product.product.6.ProducerThread.b}
ProducerThread.a putProduct {product.product.11.ProducerThread.a}
ConsumerThread.b getProduct {product.product.8.ProducerThread.a}
ConsumerThread.b getProduct {product.product.7.ProducerThread.b}
ProducerThread.b putProduct {product.product.9.ProducerThread.b}
ProducerThread.a putProduct {product.product.12.ProducerThread.a}
ConsumerThread.a getProduct {product.product.9.ProducerThread.a}
ConsumerThread.b getProduct {product.product.8.ProducerThread.b}
ProducerThread.b putProduct {product.product.10.ProducerThread.b}
ProducerThread.a putProduct {product.product.13.ProducerThread.a}
ProducerThread.b {putProduct wait}
ConsumerThread.a getProduct {product.product.10.ProducerThread.a}
ProducerThread.b putProduct {product.product.11.ProducerThread.b}
ProducerThread.a {putProduct wait}
ConsumerThread.b getProduct {product.product.11.ProducerThread.a}
ProducerThread.a putProduct {product.product.14.ProducerThread.a}
ProducerThread.b {putProduct wait}
ConsumerThread.a getProduct {product.product.9.ProducerThread.b}
ProducerThread.b putProduct {product.product.12.ProducerThread.b}
ConsumerThread.b getProduct {product.product.12.ProducerThread.a}
ProducerThread.a putProduct {product.product.15.ProducerThread.a}
ProducerThread.a {putProduct wait}
。。。。。。




分享到:
评论

相关推荐

    java多线程实现生产者和消费者

    在并发编程中,"生产者-消费者"模式是一种经典的解决问题的范式,用于协调两个或更多线程间的协作,其中一部分线程(生产者)生成数据,另一部分线程(消费者)消费这些数据。 生产者-消费者模型的核心在于共享资源...

    Java多线程设计模式_清晰完整PDF版 Java多线程设计模式源代码

    总之,Java多线程设计模式是每个Java开发者必备的技能之一。深入学习并熟练运用这些模式,将有助于你编写出更高效、稳定和易于扩展的多线程应用程序。这个PDF版教程和源代码集合是你学习多线程设计模式的理想资源,...

    Java多线程 生产者-消费者模式

    生产者-消费者模式是一种经典的多线程设计模式,用于解决数据共享问题,尤其是在一个线程生产数据而另一个线程消费数据的情况下。在这个模式中,生产者负责生成数据并放入共享的数据结构(如队列),而消费者则从这...

    JAVA多线程设计模式.pdf 下载

    标题和描述均指向了一个关于Java多线程设计模式的PDF文档的下载链接,这暗示了文档的主要内容将围绕Java中的多线程编程及其设计模式展开。在Java领域,多线程是一个核心概念,它允许程序执行多个任务同时进行,极大...

    java多线程(生产者与消费者)

    总结来说,“java多线程(生产者与消费者)”是关于如何在Java中使用同步、线程间通信和共享资源来实现高效且安全的并发编程。通过理解并熟练应用这些概念和工具,开发者可以构建出能够充分利用多核处理器能力的高...

    多线程简易实现生产者消费者模式

    总之,生产者消费者模式是多线程编程中的一种重要设计模式,它通过信号量和条件变量实现了线程间的同步和通信,有效提高了系统资源的利用率和整体效率。在Java中,我们可以借助并发库轻松实现这一模式,使得代码更加...

    java多线程设计模式_java_设计模式_多线程_多线程课题_

    Java多线程设计模式是Java开发中的核心概念,它涉及到如何高效、安全地在多个执行线程之间共享资源和协调任务。设计模式是解决特定问题的成熟方案,它们是编程经验的结晶,可以帮助开发者在面临多线程挑战时快速找到...

    java多线程设计模式详解(PDF及源码).zip

    Java多线程设计模式是Java开发中的重要领域,它涉及到如何高效、安全地利用系统资源进行并发处理。在这个主题中,我们将深入探讨单线程、生产者与消费者模型以及Java中实现多线程的各种方法。 首先,单线程是程序...

    java多线程设计模式详解.pdf

    标题“java多线程设计模式详解.pdf”中提到的知识点是关于Java多线程编程中设计模式的应用。Java多线程是并发编程的重要组成部分,设计模式则是软件工程中用于解决特定问题的最佳实践。将两者结合起来,意味着此文件...

    Java多线程设计模式(带源码)

    Java多线程设计模式是Java开发中的重要领域,它涉及到并发编程、系统性能优化以及程序的稳定性。在Java中,多线程允许程序同时执行多个任务,极大地提升了程序的执行效率。本资源提供了详细的Java多线程设计模式的...

    java 多线程 生产者消费者模式

    Java多线程编程是开发高并发、高性能应用的关键技术之一,而生产者消费者模式是多线程编程中常用的一种设计模式。它通过分离数据的生产和消费过程,实现了线程间的协同工作,有效避免了资源的竞争和浪费。在这个模式...

    Java多线程设计模式源代码

    Java多线程设计模式是Java编程中至关重要的一个领域,它涉及到如何在并发环境中高效、稳定地执行多个任务。在Java中,多线程可以提高应用程序的响应速度和整体性能,尤其是在处理I/O密集型或计算密集型任务时。本...

    java多线程设计模式详解(PDF及源码)

    本资源“java多线程设计模式详解”涵盖了这一主题的深入探讨,包括PDF文档和源码示例。 多线程设计模式是程序员在开发高效、稳定且可维护的多线程应用程序时遵循的一系列最佳实践。以下是一些常见的Java多线程设计...

    java多线程设计模式源码

    Java多线程设计模式是构建高并发、高性能应用的关键技术之一。这些模式通过优化资源利用、提高程序可读性和可维护性,使并发编程更加高效和安全。以下将详细讲解标题和描述中涉及的一些核心知识点: 1. **线程池...

    生产者和消费者模式多线程

    生产者和消费者模式是多线程编程中一个经典的设计模式,它主要解决的是在多线程环境下资源的有效利用和同步问题。在这个模式中,生产者负责生成数据,而消费者负责消费这些数据。为了保证生产与消费的平衡以及避免...

    JAVA设计模式与JAVA多线程设计模式详解

    常见的多线程设计模式有生产者消费者模式、守护线程模式、线程池模式和读写锁模式。生产者消费者模式利用阻塞队列实现数据的生产和消费,提高了系统效率;守护线程模式常用于后台服务,当所有非守护线程结束时,程序...

    java多线程设计模式

    ### Java多线程设计模式详解 #### 一、Java多线程基础 Java语言自诞生以来,便内置了对多线程的支持。多线程可以让应用程序在同一时间处理多个任务,提高程序的执行效率和响应速度。Java中创建线程有两种基本方式...

    java多线程设计模式详解

    Java多线程设计模式是Java编程中不可或缺的一部分,它涉及到如何在并发环境下高效、安全地组织代码执行。本文将深入探讨几种常见的Java多线程设计模式,并提供源码实例进行详细解析。 一、生产者消费者模式 生产者...

    java多线程之消费者生产者模式参照.pdf

    Java中的消费者生产者模式是一种经典的多线程设计模式,它用于解决两个或多个线程间的协同工作问题。在这个模式中,生产者线程负责创建资源,而消费者线程则负责消费这些资源。为了保证线程安全和有效协作,通常会...

Global site tag (gtag.js) - Google Analytics