`
wangzheguilai
  • 浏览: 21206 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类

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

阅读更多

备注说明:

该内容拷贝自网络

Introduce BlockingQueue:

 

BlockingQueue only support java 1.5 or higher,and it's defined as below.

 

public interface BlockingQueue<E>
extends
Queue<E>

 

As the definition,the parameters E is the type of elements helding in this collection. A Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element.

 

Summay of BlockingQueue methods:(as the figure)

 

 

Throws exception Special value Blocks Times out
Insert add(e) offer(e) put(e) offer(e, time, unit)
Remove remove() poll() take() poll(time, unit)
Examine element() peek() not applicable not applicable

Pls Note: A BlociingQueue does not accept null elements. Implementations throw nullPointerException on attempts to add, put or offer a null. A null is used as a sentinel value to indicate failure of poll operations.

 

Primarily designed of BlockingQueue:

 

BlockingQueue implementations are designed to be used primarily for producer-comsumer queues, but addtionally support the Collection interface. So,for example, it is possiable to remove an arbitrary element from a queue using remove(i). However, such operations are in general not performed very efficiently, and are intended for only occasional use, such as when a queued message is cancelled.

 

Of course BlockingQueue implementations are thread-safe. All queeing methods achieve their effects atomically using internal locks or other form of concurrency control. However, the bulk Collection operations addAll, containsAll, retainAll and removeAll are not necessarily performed atomically unless specified otherwise in an implementation. So it is possible, for example for addAll(c) to fail (throw an exception) after adding only some of the elements in c.

 

Sample of use BlockingQueue to implement Producer-Consumer Question :

 

1. Create a producer.

Producer.java

Java代码 复制代码 收藏代码
  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.concurrent.BlockingQueue;
  4. public class Producer implements Runnable {
  5. private BlockingQueue queue;
  6. // put producer in queue
  7. public Producer(BlockingQueue q) {
  8. this.queue = q;
  9. }
  10. public void run() {
  11. try {
  12. while (true) {
  13. // wait for a random time
  14. Thread.sleep((int) (Math.random() * 3000));
  15. queue.put(produce());
  16. }
  17. } catch (InterruptedException ex) {
  18. // catch exception
  19. }
  20. }
  21. public String produce() {
  22. List<String> product = new ArrayList<String>();
  23. String producProduct = null;
  24. product.add("Car");
  25. product.add("Phone");
  26. product.add("Plane");
  27. product.add("Computer");
  28. boolean flag = true;
  29. int getProduct = (int) (Math.random() * 3);
  30. while (flag) {
  31. if (getProduct <= product.size()) {
  32. producProduct = product.get(getProduct);
  33. flag = false;
  34. }
  35. }
  36. System.out.println("Producer producing " + producProduct);
  37. return producProduct;
  38. }
  39. }
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {

	private BlockingQueue queue;

	// put producer in queue
	public Producer(BlockingQueue q) {
		this.queue = q;
	}

	public void run() {
		try {
			while (true) {
				// wait for a random time
				Thread.sleep((int) (Math.random() * 3000));
				queue.put(produce());
			}
		} catch (InterruptedException ex) {
			// catch exception
		}
	}

	public String produce() {
		List<String> product = new ArrayList<String>();
		String producProduct = null;
		product.add("Car");
		product.add("Phone");
		product.add("Plane");
		product.add("Computer");
		boolean flag = true;
		int getProduct = (int) (Math.random() * 3);
		while (flag) {
			if (getProduct <= product.size()) {
				producProduct = product.get(getProduct);
				flag = false;
			}
		}
		System.out.println("Producer producing " + producProduct);
		return producProduct;
	}

}

 

2.Create a consumer.

Consumer.java

Java代码 复制代码 收藏代码
  1. import java.util.concurrent.BlockingQueue;
  2. public class Consumer implements Runnable {
  3. private BlockingQueue queue;
  4. public Consumer(BlockingQueue q){
  5. this.queue=q;
  6. }
  7. @Override
  8. public void run() {
  9. // TODO Auto-generated method stub
  10. try {
  11. while (true) {
  12. // wait for a random time
  13. Thread.sleep((int) (Math.random() * 3000));
  14. consume(queue.take());
  15. }
  16. } catch (InterruptedException ex) {
  17. }
  18. }
  19. public void consume(Object x) {
  20. System.out.println("Consumer buy product "+x.toString());
  21. }
  22. }
import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {

	private  BlockingQueue queue;

	public Consumer(BlockingQueue q){
		this.queue=q;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			while (true) {
				// wait for a random time
				Thread.sleep((int) (Math.random() * 3000));
				consume(queue.take());
			}
		} catch (InterruptedException ex) {
		}

	}

	public void consume(Object x) {
		System.out.println("Consumer buy product "+x.toString());
	}
}

 

3. Test Client

TestClient.java

Java代码 复制代码 收藏代码
  1. import java.util.concurrent.ArrayBlockingQueue;
  2. import java.util.concurrent.BlockingQueue;
  3. public class TestClient {
  4. /**
  5. * @param args
  6. */
  7. public static void main(String[] args) {
  8. // TODO Auto-generated method stub
  9. new TestClient();
  10. }
  11. public TestClient() {
  12. BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(1);
  13. Thread producerThread = new Thread(new Producer(queue));
  14. Thread consumerThread = new Thread(new Consumer(queue));
  15. producerThread.start();
  16. consumerThread.start();
  17. }
  18. }
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;


public class TestClient {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new TestClient();
	}

	public TestClient() {
		BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(1);
		Thread producerThread = new Thread(new Producer(queue));
		Thread consumerThread = new Thread(new Consumer(queue));
		producerThread.start();
		consumerThread.start();
	}
}

 

 

Summay:

This sample introduces BlockingQueue Class and using it to implement the Producer-Consumer Question.

分享到:
评论

相关推荐

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

    通过理解和掌握这些知识点,开发者能够有效地实现生产者-消费者模式,解决并发编程中的数据共享和协作问题。在实际项目中,这个模式常用于优化系统性能,尤其是在I/O密集型或计算密集型的应用中。

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

    总之,Java中的生产者-消费者模式是多线程编程中解决数据共享和同步问题的有效手段,通过合理利用`BlockingQueue`等并发工具类,我们可以构建高效、稳定的多线程应用。在开发过程中,了解和掌握这种模式有助于提高...

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

    java 多线程 生产者消费者模式,多个生产者对多个消费者,使用jdk 线程池及 BlockingQueue实现,解决了待生产的任务生产完成后,正常终止所有线程,避免线程(特别是消费者线程)因阻塞而无限等待的情况。源码中还简单...

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

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

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

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

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

    生产者消费者模式是一种经典的多线程同步问题解决方案,它源于现实世界中的生产流水线,用于描述生产者(Producer)和消费者(Consumer)之间的协作关系。在这个模式中,生产者负责生成产品并放入仓库,而消费者则从...

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

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

    Java多线程生产者消费者模式实现过程解析

    Java多线程生产者消费者模式实现过程解析 Java多线程生产者消费者模式是指在Java编程中,使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下,生产者负责产生数据,而消费者负责处理数据。这种...

    java 多线程生产者消费者模型demo

    Java多线程生产者消费者模型是一种典型的线程协作模式,用于解决并发编程中资源的高效利用和同步问题。在这个模型中,"生产者"线程负责生成数据,而"消费者"线程则负责处理这些数据。为了实现这种模式,Java提供了...

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

    消费者生产者模式是Java多线程编程中的重要概念,它展示了如何通过同步机制来协调线程间的操作,实现高效且安全的资源共享。这个模式在实际应用中非常常见,例如在缓存管理、数据库连接池、队列操作等场景都有所应用...

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

    1. 生产者消费者模式:通过阻塞队列实现生产者线程和消费者线程之间的数据交换,确保生产速度与消费速度的平衡,避免资源浪费。Java中的BlockingQueue接口和相关实现类如ArrayBlockingQueue、LinkedBlockingQueue等...

    Java 生产者消费者模式

    在Java编程中,生产者消费者模式是一种典型的多线程协作模型,用于解决系统资源供需不平衡的问题。这个模式的核心思想是将生产数据和消费数据的过程解耦,使得生产者可以独立地生产数据,而消费者可以独立地消费数据...

    java多线程_消费者与生产者模型

    在Java多线程编程中,消费者-生产者模型是一种经典的线程间通信模式,用于解决多线程环境下的数据共享问题。该模型涉及到两个主要的角色:生产者(Producer)和消费者(Consumer)。生产者负责创建数据,而消费者则...

    Java 生产消费者模式

    5. **死锁与饥饿**:在实现生产消费者模式时,要防止死锁(两个或更多线程相互等待对方释放资源)和饥饿(某个线程因资源不足或优先级问题无法获得执行机会)。合理设置队列大小、使用适当的同步机制可以避免这些...

    Java JDK1.5 生产消费者模式解决方案

    在Java编程语言中,生产者消费者模式是一种经典的多线程设计模式,用于处理并发问题。在JDK 1.5及以后的版本中,Java引入了`java.util.concurrent`包,其中包含了一些强大的并发工具类,如`Lock`接口和`Condition`...

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

    生产者消费者模式是解决线程间通信的经典设计模式之一。在这个模式中,生产者负责生成数据并将其放入一个共享队列中,而消费者则从队列中取出数据进行处理。这种模式有效地解决了资源竞争和死锁问题,确保了线程间的...

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

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

    JAVA多线程实现生产者消费者的实例详解

    JAVA多线程实现生产者消费者的实例详解 JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式,描述了生产者和消费...

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

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

Global site tag (gtag.js) - Google Analytics