Java 阻塞队列

最新推荐文章于 2024-07-29 21:55:07 发布

wenyufei2013

最新推荐文章于 2024-07-29 21:55:07 发布

阅读量300

点赞数

分类专栏：学习文章标签：阻塞队列 Java

本文链接：https://blog.csdn.net/wenyufei2013/article/details/80457244

版权

学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

阻塞队列（BlockingQueue）

栈和队列是在程序设计中被广泛使用的两种线性数据结构

Java5提供了阻塞队列的接口BlockingQueue，阻塞队列的概念是，一个指定长度的队列，如果队列满了，添加新元素的操作会被阻塞等待，直到有空位为止。同样，当队列为空时候，请求队列元素的操作同样会阻塞等待，直到有可用元素为止。

Java阻塞队列应用于生产者消费者模式、消息传递、并行任务执行和相关并发设计的大多数常见使用上下文。

程序的两个线程通过交替向BlockingQueue 中放入元素、取出元素，即可很好地控制线程的通信。

BlockingQueue 提供了两个支持阻塞的方法：

1）put(E e)

尝试把E元素放入BlockingQueue 中，如果该队列的元素已满，则阻塞该线程。

2）take()

尝试从BlockingQueue 的头部取出元素，如果该队列的元素已空，则阻塞该线程。

BlockingQueue定义的常用方法如下:

1）add(anObject)：把anObject加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则招聘异常

2）offer(anObject)：表示如果可能的话，将anObject加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false。

3）put(anObject)：把anObject加到BlockingQueue里，如果BlockQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

4）poll(time)：取走BlockingQueue里排在首位的对象，若不能立即取出，则可以等time参数规定的时间,取不到时返回null

5）take()：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到Blocking有新的对象被加入为止

BlockingQueue 包含的方法之间的对应关系

BlockingQueue有四个具体的实现类，根据不同需求，选择不同的实现类

1）ArrayBlockingQueue：规定大小的BlockingQueue，其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出）顺序排序的.

2）LinkedBlockingQueue：大小不定的BlockingQueue，若其构造函数带一个规定大小的参数，生成的BlockingQueue有大小限制，若不带大小参数，所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出）顺序排序的

3）PriorityBlockingQueue：类似于LinkedBlockQueue，但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数的Comparator决定的顺序.

4）SynchronousQueue：特殊的BlockingQueue，对其的操作必须是放和取交替完成的。

package com.hainiu.list;

import java.util.concurrent.ArrayBlockingQueue;

import com.hainiu.thread.Call;
/**
    阻塞队列实现生产消费模式
*/
public class Test {
	public static void main(String[] args) {
		ArrayBlockingQueue<Call> abk = new ArrayBlockingQueue<>(3);
		Test test = new Test();
		Runnable sc = test.new SC(abk);
		new Thread(sc,"生产者1号").start();
		new Thread(sc,"生产者2号").start();
		new Thread(sc,"生产者3号").start();
		Runnable xf =test.new XF(abk);
		new Thread(xf,"	xiaofeizhe 	1号##").start();
		new Thread(xf,"	xiaofeizhe 	2号##").start();
		new Thread(xf,"	xiaofeizhe	3号##").start();
	}

	/**
	 * 生产线程
	 */
	class SC implements Runnable {
		int i = 1;
		ArrayBlockingQueue<Call> abk;
		public SC() {
			// TODO Auto-generated constructor stub
		}
		public SC( ArrayBlockingQueue<Call> abk) {
			super();
			this.abk = abk;
		}
		@Override
		public void run() {
			Call call = null;
			String name = null;
			String x = null;
			while(true){
				if( i %2 == 0){
					name = "华为";
					x = "荣耀";
				}else{
					name = "apple";
					x = " XXXXXX ";
				}
				synchronized (this) {
					// 创建一个手机对象
					call = new Call(name , x , i);
	
					i++;
				}
				try {
					// 该方法为 阻塞方法      如果队里满了 那么会自动阻塞
					abk.put(call);
					//System.out.println(Thread.currentThread().getName()+" 成功的放入货架一个产品   信息为 : "+call);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}

	}

	/**
	 * 消费线程
	 */
	class XF implements Runnable {
		ArrayBlockingQueue<Call> abk;
		public XF() {
			// TODO Auto-generated constructor stub
		}
		public XF( ArrayBlockingQueue<Call> abk) {
			super();
			this.abk = abk;
		}

		@Override
		public void run() {
			while(true){
				try {
					// 拿取一个   如果没有数据那么久阻塞
					Call call = abk.take();
					System.out.println(Thread.currentThread().getName()+"  成功卖出一个产品   "+call);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}