BlockingQueue的使用

最新推荐文章于 2019-04-15 19:12:23 发布
最新推荐文章于 2019-04-15 19:12:23 发布
阅读量807 收藏
点赞数
分类专栏： JAVA 文章标签： Java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ldrmcml/article/details/44871963
版权

1、BlockingQueue常用API如下：


截图自：http://dlc-cdn.sun.com/jdk/jdk-api-localizations/jdk-api-zh-cn/publish/1.6.0/html/zh_CN/api/java/util/concurrent/BlockingQueue.html

1.1、放入数据：

         offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,

　　　　则返回true,否则返回false.（本方法不阻塞当前执行方法的线程）
　　offer(E o, long timeout, TimeUnit unit),可以设定等待的时间，如果在指定的时间内，还不能往队列中
　　　　加入BlockingQueue，则返回失败。
　　put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断
　　　　直到BlockingQueue里面有空间再继续.

1.2、获取数据：

　　poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,
　　　　取不到时返回null;
　　poll(long timeout, TimeUnit unit)：从BlockingQueue取出一个队首的对象，如果在指定时间内，
　　　　队列一旦有数据可取，则立即返回队列中的数据。否则知道时间超时还没有数据可取，返回失败。
　　 take(): 取走 BlockingQueue 里排在首位的对象 , 若 BlockingQueue 为空 , 阻断进入等待状态直到
　　　　 BlockingQueue 有新的数据被加入;  
　　drainTo():一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数）， 
　　　　通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁。

2、BlockingQueue接口的具体实现类如下：



引自：http://blog.youkuaiyun.com/vernonzheng/article/details/8247564

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

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

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

    4)SynchronousQueue:特殊的BlockingQueue,对其的操作必须是放和取交替完成的.

    其中LinkedBlockingQueue和ArrayBlockingQueue比较起来,它们背后所用的数据结构不一样,导致LinkedBlockingQueue的数据吞吐量要大于ArrayBlockingQueue,但在线程数量很大时其性能的可预见性低于ArrayBlockingQueue.  

3、应用1——ArrayBlockingQueue

package concurrency;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BlockingQueueTest {
	// 定义装苹果的篮子，用BlockingQueue模拟
	public static class Basket{
		// 篮子，能够装5个苹果
		// ArrayBlockingQueue必须有容量限制
		private final BlockingQueue<String> basket=new ArrayBlockingQueue<String>(5);
		// 生产苹果
		public void produce(){
			try{
				basket.put("An apple");
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
		// 消费苹果
		public String consume(){
			String str=null;
			try{
				str=basket.take();
			}catch(InterruptedException e){
				e.printStackTrace();
			}
			return str;
		}
	}
	// 测试方法
	public static void testBasket(){
		// 实例化篮子
		final Basket basket=new Basket();
		// 定义苹果生产者
		class Producer implements Runnable{
			public void run(){
				while(true){
					// 生产苹果
					System.out.println("准备生产苹果："+
							System.currentTimeMillis());
					basket.produce();
					System.out.println("生产苹果完毕："+
							System.currentTimeMillis());
					try{
						Thread.sleep(300);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
				}
			}
		}
		// 定义苹果消费者
		class Consumer implements Runnable{
			public void run(){
				while(true){
					// 消费苹果
					System.out.println("准备消费苹果："+
							System.currentTimeMillis());
					basket.consume();
					System.out.println("消费苹果完毕："+
							System.currentTimeMillis());
					try{
						Thread.sleep(500);
					}catch(InterruptedException e){
						e.printStackTrace();
					}
				}
			}
		}
		ExecutorService exec=Executors.newCachedThreadPool();
		Producer producer=new Producer();
		Consumer consumer=new Consumer();
		exec.execute(producer);
		exec.execute(consumer);
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// 强行终止正在执行的线程，shutdown等待正在执行的线程结束，等待列表的线程不再执行
		exec.shutdownNow();
	}
	public static void main(String[] args){
		testBasket();
	}
}

输出结果：如下：exec.shutdownNow()只是试图去强制关闭正在执行的线程，事实上并没有真正关闭成功。本例是手动停止程序运行的，否则会一直持续运行。

准备生产苹果：1428121675968
生产苹果完毕：1428121675968
准备消费苹果：1428121675968
消费苹果完毕：1428121675968
准备生产苹果：1428121676265
生产苹果完毕：1428121676265
准备消费苹果：1428121676468
消费苹果完毕：1428121676468
准备生产苹果：1428121676562
生产苹果完毕：1428121676562
准备生产苹果：1428121676874
生产苹果完毕：1428121676874
准备消费苹果：1428121676968
消费苹果完毕：1428121676968
准备生产苹果：1428121677171
生产苹果完毕：1428121677171
准备消费苹果：1428121677468
消费苹果完毕：1428121677468
准备生产苹果：1428121677468
生产苹果完毕：1428121677468
准备生产苹果：1428121677765
生产苹果完毕：1428121677765
准备消费苹果：1428121677968
消费苹果完毕：1428121677968
准备生产苹果：1428121678078
生产苹果完毕：1428121678078
准备生产苹果：1428121678374
生产苹果完毕：1428121678374
准备消费苹果：1428121678468
消费苹果完毕：1428121678468
准备生产苹果：1428121678671
生产苹果完毕：1428121678671
准备消费苹果：1428121678968
消费苹果完毕：1428121678968
准备生产苹果：1428121678968
生产苹果完毕：1428121678968
准备生产苹果：1428121679281
生产苹果完毕：1428121679281
准备消费苹果：1428121679468
消费苹果完毕：1428121679468
准备生产苹果：1428121679578
生产苹果完毕：1428121679578
准备生产苹果：1428121679874
准备消费苹果：1428121679968
生产苹果完毕：1428121679968
消费苹果完毕：1428121679968
准备生产苹果：1428121680265
准备消费苹果：1428121680468
消费苹果完毕：1428121680468
生产苹果完毕：1428121680468
准备生产苹果：1428121680765
java.lang.InterruptedException: sleep interrupted
生产苹果完毕：1428121680968
准备消费苹果：1428121680968
消费苹果完毕：1428121680968
	at java.lang.Thread.sleep(Native Method)
	at concurrency.BlockingQueueDemo$1Consumer.run(BlockingQueueDemo.java:66)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)
java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.reportInterruptAfterWait(Unknown Source)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(Unknown Source)
	at java.util.concurrent.ArrayBlockingQueue.put(Unknown Source)
	at concurrency.BlockingQueueDemo$Basket.produce(BlockingQueueDemo.java:17)
	at concurrency.BlockingQueueDemo$1Producer.run(BlockingQueueDemo.java:44)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)
准备生产苹果：1428121681265
生产苹果完毕：1428121681265
准备消费苹果：1428121681468
消费苹果完毕：1428121681468
准备生产苹果：1428121681578
生产苹果完毕：1428121681578
准备生产苹果：1428121681874
准备消费苹果：1428121681968
消费苹果完毕：1428121681968
生产苹果完毕：1428121681968
准备生产苹果：1428121682265


4、应用2——LinkedBlockingQueue

BlockingQueueTest测试类： 
package concurrency;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
 
/**
 * @author jackyuj
 */
public class BlockingQueueTest {
 
    public static void main(String[] args) throws InterruptedException {
        // 声明一个容量为10的缓存队列
        BlockingQueue<String> queue = new LinkedBlockingQueue<String>(10);
 
        Producer producer1 = new Producer(queue);
        Producer producer2 = new Producer(queue);
        Producer producer3 = new Producer(queue);
        Consumer consumer = new Consumer(queue);
 
        // 借助Executors
        ExecutorService service = Executors.newCachedThreadPool();
        // 启动线程
        service.execute(producer1);
        service.execute(producer2);
        service.execute(producer3);
        service.execute(consumer);
 
        // 执行10s
        Thread.sleep(10 * 1000);
        producer1.stop();
        producer2.stop();
        producer3.stop();
 
        Thread.sleep(2000);
        // 退出Executor
        service.shutdown();
    }
}

Producer类： 
package concurrency;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
 
/**
 * 生产者线程
 * 
 * @author jackyuj
 */
public class Producer implements Runnable {
 
    public Producer(BlockingQueue queue) {
        this.queue = queue;
    }
 
    public void run() {
        String data = null;
        Random r = new Random();
 
        System.out.println("启动生产者线程！");
        try {
            while (isRunning) {
                System.out.println("正在生产数据...");
                Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));
 
                data = "data:" + count.incrementAndGet();
                System.out.println("将数据：" + data + "放入队列...");
                if (!queue.offer(data, 2, TimeUnit.SECONDS)) {
                    System.out.println("放入数据失败：" + data);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        } finally {
            System.out.println("退出生产者线程！");
        }
    }
 
    public void stop() {
        isRunning = false;
    }
 
    private volatile boolean      isRunning               = true;
    private BlockingQueue queue;
    private static AtomicInteger  count                   = new AtomicInteger();
    private static final int      DEFAULT_RANGE_FOR_SLEEP = 1000;
 
}

Consumer类： 
package concurrency;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
 
/**
 * 消费者线程
 * 
 * @author jackyuj
 */
public class Consumer implements Runnable {
 
    public Consumer(BlockingQueue<String> queue) {
        this.queue = queue;
    }
 
    public void run() {
        System.out.println("启动消费者线程！");
        Random r = new Random();
        boolean isRunning = true;
        try {
            while (isRunning) {
                System.out.println("正从队列获取数据...");
                String data = queue.poll(2, TimeUnit.SECONDS);
                if (null != data) {
                    System.out.println("拿到数据：" + data);
                    System.out.println("正在消费数据：" + data);
                    Thread.sleep(r.nextInt(DEFAULT_RANGE_FOR_SLEEP));
                } else {
                    // 超过2s还没数据，认为所有生产线程都已经退出，自动退出消费线程。
                    isRunning = false;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        } finally {
            System.out.println("退出消费者线程！");
        }
    }
 
    private BlockingQueue<String> queue;
    private static final int      DEFAULT_RANGE_FOR_SLEEP = 1000;
}

输出结果： 
启动生产者线程！
正在生产数据...
启动消费者线程！
正从队列获取数据...
启动生产者线程！
正在生产数据...
启动生产者线程！
正在生产数据...
将数据：data:1放入队列...
正在生产数据...
拿到数据：data:1
正在消费数据：data:1
将数据：data:2放入队列...
正在生产数据...
将数据：data:3放入队列...
正在生产数据...
将数据：data:4放入队列...
正在生产数据...
将数据：data:5放入队列...
正在生产数据...
正从队列获取数据...
拿到数据：data:2
正在消费数据：data:2
将数据：data:6放入队列...
正在生产数据...
正从队列获取数据...
拿到数据：data:3
正在消费数据：data:3
将数据：data:7放入队列...
正在生产数据...
将数据：data:8放入队列...
正在生产数据...
将数据：data:9放入队列...
正在生产数据...
将数据：data:10放入队列...
正在生产数据...
将数据：data:11放入队列...
正在生产数据...
将数据：data:12放入队列...
正在生产数据...
正从队列获取数据...
拿到数据：data:4
正在消费数据：data:4
将数据：data:13放入队列...
正在生产数据...
正从队列获取数据...
拿到数据：data:5
正在消费数据：data:5
将数据：data:14放入队列...
正在生产数据...
将数据：data:15放入队列...
正在生产数据...
正从队列获取数据...
拿到数据：data:6
正在消费数据：data:6
正从队列获取数据...
拿到数据：data:7
将数据：data:16放入队列...
正在消费数据：data:7
正在生产数据...
将数据：data:17放入队列...
正在生产数据...
将数据：data:18放入队列...
正从队列获取数据...
拿到数据：data:8
正在消费数据：data:8
正在生产数据...
正从队列获取数据...
拿到数据：data:9
正在消费数据：data:9
将数据：data:19放入队列...
正在生产数据...
将数据：data:20放入队列...
将数据：data:21放入队列...
正从队列获取数据...
拿到数据：data:10
正在消费数据：data:10
正在生产数据...
将数据：data:22放入队列...
将数据：data:23放入队列...
正从队列获取数据...
正在生产数据...
拿到数据：data:11
正在消费数据：data:11
正从队列获取数据...
拿到数据：data:12
正在消费数据：data:12
正在生产数据...
正从队列获取数据...
拿到数据：data:13
正在消费数据：data:13
正在生产数据...
将数据：data:24放入队列...
将数据：data:25放入队列...
将数据：data:26放入队列...
正从队列获取数据...
拿到数据：data:14
正在消费数据：data:14
正在生产数据...
将数据：data:27放入队列...
正从队列获取数据...
正在生产数据...
拿到数据：data:15
正在消费数据：data:15
正从队列获取数据...
正在生产数据...
拿到数据：data:16
正在消费数据：data:16
正从队列获取数据...
正在生产数据...
拿到数据：data:17
正在消费数据：data:17
将数据：data:28放入队列...
将数据：data:29放入队列...
将数据：data:30放入队列...
正从队列获取数据...
正在生产数据...
拿到数据：data:18
正在消费数据：data:18
正从队列获取数据...
正在生产数据...
拿到数据：data:19
正在消费数据：data:19
将数据：data:31放入队列...
正从队列获取数据...
拿到数据：data:20
正在生产数据...
正在消费数据：data:20
将数据：data:32放入队列...
正从队列获取数据...
拿到数据：data:21
正在生产数据...
正在消费数据：data:21
将数据：data:33放入队列...
正从队列获取数据...
拿到数据：data:22
正在消费数据：data:22
正在生产数据...
将数据：data:34放入队列...
正从队列获取数据...
拿到数据：data:23
正在消费数据：data:23
退出生产者线程！
将数据：data:35放入队列...
正从队列获取数据...
退出生产者线程！
拿到数据：data:24
正在消费数据：data:24
正从队列获取数据...
拿到数据：data:25
退出生产者线程！
正在消费数据：data:25
正从队列获取数据...
拿到数据：data:26
正在消费数据：data:26
正从队列获取数据...
拿到数据：data:27
正在消费数据：data:27
正从队列获取数据...
拿到数据：data:28
正在消费数据：data:28
正从队列获取数据...
拿到数据：data:29
正在消费数据：data:29
正从队列获取数据...
拿到数据：data:30
正在消费数据：data:30
正从队列获取数据...
拿到数据：data:31
正在消费数据：data:31
正从队列获取数据...
拿到数据：data:32
正在消费数据：data:32
正从队列获取数据...
拿到数据：data:33
正在消费数据：data:33
正从队列获取数据...
拿到数据：data:34
正在消费数据：data:34
正从队列获取数据...
拿到数据：data:35
正在消费数据：data:35
正从队列获取数据...
退出消费者线程！

参考链接：
BlockingQueue队列详解 
java 持久监听blockqueue的变化_Java并发ThreadPoolExecutor+BlockingQueue使用详解
weixin_39636645的博客
03-07 805
前言从Java线程池及用法 一文中我们知道，Java提供了4个常用的线程池。但是在如下场景的的时候，就需要我们使用自定义ThreadPoolExecutor和BlockingQueue队列结合使用来处理。需要的子线程数量很多，但是数量不确定。子线程有自己的优先级，根据优先级来确定执行的先后顺序。监听线程池的开始，结束，关闭等状态。ThreadPoolExecutor构造方法//使用给定的初始参数和...
生产者-消费者-BlockingQueue
oceanZhao的专栏
09-08 749
本例介绍一个特殊的队列：BlockingQueue，如果BlockingQueue是空的，从BlockingQueue取东西的操作将会被阻断进入 等待状态，直到BlockingQueue进了东西才会被唤醒，同样，如果BlockingQueue是满的，任何试图往里存东西的操作也会被
BlockingQueue简介及使用
Cherry_tly的专栏
01-06 588
本例介绍一个特殊的队列:BlockingQueue,如果BlockQueue是空的,从BlockingQueue取东西的操作将会被阻断进入等待状态,直到BlockingQueue进了东西才会被唤醒.同样,如果BlockingQueue是满的,任何试图往里存东西的操作也会被阻断进入等待状态,直到BlockingQueue里有空间才会被唤醒继续操作.     使用BlockingQueue的关键
阻塞队列BlockingQueue的使用
01-07
在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文简要介绍下BlockingQueue...
spring-blockingqueue:用Spring Boot阻止队列
05-16
当我们谈论"Spring BlockingQueue"时，我们实际上是在讨论如何在Spring Boot应用中使用Java并发库中的BlockingQueue接口。 BlockingQueue是一种线程安全的数据结构，它在多线程环境下的数据共享和通信中扮演着关键...
基于java中BlockingQueue的使用介绍
09-05
**基于Java中的BlockingQueue使用介绍** Java的并发编程框架提供了多种高级并发工具，其中BlockingQueue是一种非常实用的数据结构，它实现了生产者-消费者模式。在多线程环境下，BlockingQueue可以高效地处理线程间...
【Java数据结构高级应用】：BlockingQueue使用场景优化分析
[【Java数据结构高级应用】：BlockingQueue使用场景优化分析](https://cdn.programiz.com/sites/tutorial2program/files/java-blockingqueue.png) # 1. Java BlockingQueue 概述 Java的`BlockingQueue`是一个接口，...
特殊的队列:BlockingQueue
烂锅烂铁
02-28 223
import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** ...
BlockingQueue 使用
搬砖人的博客
04-15 192
抛出异常 特殊值 阻塞 超时 插入 add(e) offer(e) put(e) offer(e，time，unit) 移除 remove() poll() take() poll(time,unit) 检查 element() peek() 不可用 不可用 ...
BlockingQueue的简单使用
Wellven_chen的博客
05-08 2001
BlockingQueue是一个阻塞队列，用户可以为该队列设置一个初始容量（即该队列中最多能够放入多少个数据）。 既然是队列，那么肯定是由顺序的，我们可以调用给定的API依次获取往该队列中值的设置顺序。 第一步.  创建BlockingQueue的封装类，BlockingQueue能够在创建对象的时候使用泛型来规定队列的类型 package com.MessageQueue; imp
Java多线程-工具篇-BlockingQueue
weixin_30933531的博客
11-24 4070
前言： 在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 认识BlockingQueue阻塞队列，顾名思义，首先它是一个队列，而一个...
java中自动实现生产者消费者模式的队列
余炜的博客
03-22 346
/**     本例介绍一个特殊的队列:BlockingQueue,如果BlockQueue是空的,从BlockingQueue取东西的操作将会被阻断进入等待状 态,直到BlockingQueue进了东西才会被唤醒.同样,如果BlockingQueue是满的,任何试图往里存东西的操作也会被阻断进入等待状 态,直到BlockingQueue里有空间才会被唤醒继续操作.     本例再次实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值