`
xurichusheng
  • 浏览: 343910 次
  • 性别: Icon_minigender_1
  • 来自: 南京
社区版块
存档分类
最新评论

java多线程 生产者-消费者

    博客分类:
  • java
阅读更多

 

 

对于此模型,应该明确一下几点:
1、生产者仅仅在仓储未满时候生产,仓满则停止生产。
2、消费者仅仅在仓储有产品时候才能消费,仓空则等待。
3、当消费者发现仓储没产品可消费时候会通知生产者生产。
4、生产者在生产出可消费产品时候,应该通知等待的消费者去消费。 

 

要消费的实体 : Message

   

/**
 * @ClassName: Message
 * @Description: "生产者-消费者"模型中要消费的实体
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class Message {

	public static int messageId;
	private String content;
	
	/**
	 * @return 返回 messageId
	 */
	public static int getMessageId() {
		return messageId;
	}
	/**
	 * @param 对messageId进行赋值
	 */
	public static void setMessageId(int messageId) {
		Message.messageId = messageId;
	}
	/**
	 * @return 返回 content
	 */
	public String getContent() {
		return content;
	}
	/**
	 * @param 对content进行赋值
	 */
	public void setContent(String content) {
		this.content = content;
	}
}

 

消费者 : Consumer

   

/**
 * @ClassName: Consumer
 * @Description: 消费者
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class Consumer implements Runnable {

	//消息队列
	private MessageQueue queue;

	/**
	 * <p>Title: Consumer</p>
	 * <p>Description: 构造方法</p>
	 * @param queue
	 */
	public Consumer(MessageQueue queue) {
		this.queue = queue;
	}

	/**
	 * <p>Title: run</p>
	 * <p>Description: 执行线程</p>
	 * @see java.lang.Thread#run()
	 * @author 
	 */
	public void run() {

		while (true) {
			//消费
			queue.consume();
			
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}

 

生产者: Producer

   

/**
 * @ClassName: Producer
 * @Description: 生产者
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class Producer implements Runnable {

	//消息队列
	private MessageQueue queue;
	
	/**
	 * <p>Title: Producer</p>
	 * <p>Description: 构造方法</p>
	 * @param queue
	 */
	public Producer(MessageQueue queue){
		this.queue = queue;
	}
	
	/**
	 * <p>Title: run</p>
	 * <p>Description: 执行线程</p>
	 * @see java.lang.Thread#run()
	 * @author 
	 */
	@SuppressWarnings("static-access")
	public void run(){
		
		//要生产的实体
		Message message = null;
		
		while (true){
			
			message = new Message();
			
			message.setMessageId(++Message.messageId);
			message.setContent("food"+Message.messageId);
			
			//生产
			queue.produce(message);
			
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 

消息队列 : MessageQueue

   

/**
 * @ClassName: MessageQueue
 * @Description: 消息队列
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class MessageQueue {

	private static Logger log = Logger.getLogger(MessageQueue.class);

	// 队列
	List<Message> queue = new ArrayList<Message>(10);

	/** 队列中message对象的最大值,默认为500 */
	int maxMessageNum = 500;

	/**
	 * @Title: produce
	 * @Description: 生产
	 * @param message
	 *            要生产的实体
	 * @author 
	 */
	public synchronized void produce(Message message) {

		try {
			while (queue.size() == maxMessageNum) {

				log.info(Thread.currentThread().getName() + ",队列满,等待中...");

				this.wait();
			}
		} catch (InterruptedException e) {
			log.error("wait() exception.", e);
		}

		queue.add(message);

		log.info(Thread.currentThread().getName() + ",正在生产"
				+ message.getContent() + ",当前个数:" + getCount());

		notifyAll();
	}

	/**
	 * @Title: consume
	 * @Description: 消费
	 * @param message
	 *            要消费的实体
	 * @author 
	 */
	public synchronized void consume() {

		try {
			while (queue.size() == 0) {

				log.info(Thread.currentThread().getName() + ",队列空,等待中...");

				this.wait();
			}
		} catch (InterruptedException e) {
			log.error("wait() exception.", e);
		}
		
		Message message = queue.get(0);
		queue.remove(message);

		log.info(Thread.currentThread().getName() + "正在消费"
				+ message.getContent() + "。。。 ,当前个数: " + getCount());

		notifyAll();
	}

	/**
	 * @Title: getCount
	 * @Description: 获取队列中的当前个数
	 * @return [描述]
	 * @author 
	 */
	private int getCount() {

		synchronized (this) {
			return queue.size();
		}
	}
}

 

测试类 :Test

  

/**
 * @ClassName: Test
 * @Description: 测试
 * @author 
 * @date 2011-8-17
 * @version V1.0
 */
public class Test {

	/**@Title: main
	 * @Description: 测试
	 * @param args 
	 * @author 
	 */
	public static void main(String[] args) {

		MessageQueue queue = new MessageQueue();
		
		Producer wQ1 = new Producer(queue);
		Producer wQ2 = new Producer(queue);
	  
		Consumer rQ1 = new Consumer(queue);
		Consumer rQ2 = new Consumer(queue);
		Consumer rQ3 = new Consumer(queue);
	  
		Thread threadWQ1 = new Thread(wQ1, "thread-wQ1");
		Thread threadWQ2 = new Thread(wQ2, "thread-wQ2");

		Thread threadRQ1 = new Thread(rQ1, "thread-rQ1");
		Thread threadRQ2 = new Thread(rQ2, "thread-rQ2");
		Thread threadRQ3 = new Thread(rQ3, "thread-rQ3");
	  
		threadWQ1.start();
		threadWQ2.start();
	  
		threadRQ1.start();
		threadRQ2.start();
		threadRQ3.start();
	}

}

 

 

分享到:
评论

相关推荐

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

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

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

    本示例中的“生产者-消费者”模型是一种经典的多线程问题,它模拟了实际生产环境中的资源分配与消耗过程。下面我们将详细探讨如何在Java中实现这个模型。 首先,我们要理解生产者-消费者模型的基本概念。在这个模型...

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

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

    java多线程经典模型生产者消费者

    java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型...

    生产者-消费者多线程处理

    在本场景中,我们关注的是一个经典的多线程问题——"生产者-消费者"模式。这个模式是解决资源管理与同步问题的一个有效策略,它在操作系统、并发编程和分布式系统等领域广泛应用。 生产者-消费者模型涉及到两个主要...

    【IT十八掌徐培成】Java基础第08天-04.多线程-生产者-消费者.zip

    通过学习和实践"生产者-消费者"模型,开发者能够更好地理解和掌握Java多线程的精髓,为构建高并发、高效率的应用打下坚实的基础。在实际项目中,这种模型常被用于实现缓存管理、消息队列以及数据库连接池等场景。

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

    生产者消费者模式是一种设计模式,它描述了两个不同类型的线程如何协作完成工作:生产者负责生成数据,而消费者负责消耗这些数据。为了使这个模式在多线程环境下安全运行,我们需要使用Java中的同步机制。 1. **...

    Java线程间的通信----生产者消费者模型

    生产者消费者模型是一种经典的线程同步问题,它模拟了实际生活中的生产过程和消费过程,使得生产者线程可以将数据生产出来,而消费者线程则负责消耗这些数据,两者之间通过共享数据结构进行协同工作。 生产者消费者...

    【IT十八掌徐培成】Java基础第08天-05.多线程-生产者-消费者2.zip

    "生产者-消费者"模式是多线程编程中的一个经典设计模式,它体现了线程间的协作和同步。在这个模式中,"生产者"线程负责创建资源,而"消费者"线程则负责消耗这些资源。这个模式在实际应用中非常常见,例如在消息队列...

    基于JAVA线程机制研究生产者-消费者问题.pdf

    在Java中实现生产者-消费者问题不仅能够加深对Java多线程编程的理解,还能够锻炼出良好的并发编程思维,这对于未来在软件工程和系统开发等领域的工作至关重要。 总之,基于Java线程机制研究生产者-消费者问题,通过...

    用多线程同步方法解决生产者-消费者问题

    生产者-消费者问题是这种并发模型的一个经典案例,它涉及到如何在多个线程间共享资源,确保数据的一致性和正确性。在这个场景中,生产者线程负责生成数据并放入一个有限的缓冲区,而消费者线程则负责从缓冲区取出...

    java多线程实现生产者消费者问题

    用java多线程,实现生产者消费者同步和互斥的问题,操作系统中的经典问题

    多线程间通信:多生产者-多消费者实例

    本文将深入探讨“多生产者-多消费者”模式,这是一种经典的线程同步问题,旨在优化资源的利用和提高系统的效率。在这个模式中,多个生产者线程生成数据,而多个消费者线程则负责消费这些数据。为了确保数据的一致性...

    java多线程实现生产者消费者关系

    在实际应用中,我们常常会遇到一种典型的多线程问题——生产者消费者模型。这个模型描述了两种类型的线程:生产者线程负责创建或生产资源,而消费者线程则负责消耗这些资源。在Java中,我们可以利用同步机制来实现...

    Java多线程-生产者与消费者问题

    ### Java多线程-生产者与消费者问题 #### 一、生产者与消费者问题概览 **1.1 概要** 生产者与消费者问题是计算机科学中一个多线程同步的经典问题。它描述了两个线程如何共享有限资源的场景:一个是生产者...

    Java多线程编程总结

    Java线程:并发协作-生产者消费者模型 Java线程:并发协作-死锁 Java线程:volatile关键字 Java线程:新特征-线程池 Java线程:新特征-有返回值的线程 Java线程:新特征-锁(上) Java线程:新特征-锁(下) Java...

    java多线程例子-生产者消费者

    在本示例中,“java多线程例子-生产者消费者”旨在展示如何利用多线程来实现生产者和消费者模式。这种模式是并发编程中的经典设计模式,用于协调生产数据和消费数据的两个不同线程。 生产者消费者模式的基本概念是...

    JAVA_生产者-消费者

    在Java编程中,"生产者-消费者"模式是一种经典的多线程问题,它涉及到了并发处理和资源管理。这个模式的主要目标是通过分离生产数据和消费数据的过程,提高系统的效率和灵活性。在这个模式中,"生产者"负责生成数据...

    基于JAVA线程机制研究生产者-消费者问题.zip

    生产者-消费者问题是多线程编程中的一个经典模型,用于演示线程间的协作和同步。这个模型描述了两个角色——生产者和消费者,它们共享一个有限的缓冲区。生产者负责创建产品并放入缓冲区,而消费者则从缓冲区取出...

Global site tag (gtag.js) - Google Analytics