学习阻塞队列BlockingQueue
来源:互联网 发布:网络侠客行txt下载 编辑:程序博客网 时间:2024/06/03 18:08
如果BlockQueue是空的,从BlockingQueue取东西的操作将会被阻断进入等待状态,直到BlockingQueue进了东西才会被唤醒.同样,如果BlockingQueue是满的,任何试图往里存东西的操作也会被阻断进入等待状态,直到BlockingQueue里有空间才会被唤醒继续操作.
1.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有新的对象被加入为止
6)drainTo()
一次性从BlockingQueue获取所有可用的数据对象(还可以指定获取数据的个数), 通过该方法,可以提升获取数据效率;不需要多次分批加锁或释放锁。
这四套方法对应的特点分别是:
1. ThrowsException:如果操作不能马上进行,则抛出异常2. SpecialValue:如果操作不能马上进行,将会返回一个特殊的值,一般是true或者false3. Blocks:如果操作不能马上进行,操作会被阻塞4. TimesOut:如果操作不能马上进行,操作会被阻塞指定的时间,如果指定时间没执行,则返回一个特殊值,一般是true或者false
2.BlockingQueue具体的实现类,根据不同需求,选择不同的实现类
1)ArrayBlockingQueue
规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的.
BlockingQueue queue = new ArrayBlockingQueue(1024);queue.put("1");Object object = queue.take();
2)LinkedBlockingQueue
大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.
和ArrayBlockingQueue一样,LinkedBlockingQueue 也是以先进先出的方式存储数据,最新插入的对象是尾部,最新移出的对象是头部。下面是一个初始化和使LinkedBlockingQueue的例子:
BlockingQueue<String> unbounded = new LinkedBlockingQueue<String>();BlockingQueue<String> bounded = new LinkedBlockingQueue<String>(1024);bounded.put("Value");String value = bounded.take();
ArrayBlockingQueue和LinkedBlockingQueue是两个最普通也是最常用的阻塞队列,一般情况下,在处理多线程间的生产者消费者问题,使用这两个类足以。
生产者消费者实例:
import java.util.concurrent.BlockingQueue;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.LinkedBlockingQueue;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(); }}
import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;/** * 生产者 */public class Producer implements Runnable { private volatile boolean isRunning = true; private BlockingQueue queue; private static AtomicInteger count = new AtomicInteger(); private static final int DEFAULT_RANGE_FOR_SLEEP = 1000; 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; }}
import java.util.Random;import java.util.concurrent.BlockingQueue;import java.util.concurrent.TimeUnit;/** * 消费者 */public class Consumer implements Runnable { private BlockingQueue<String> queue; private static final int DEFAULT_RANGE_FOR_SLEEP = 1000; 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("退出消费者线程!"); } }}
3)DelayQueue
DelayQueue中的元素只有当其指定的延迟时间到了,才能够从队列中获取到该元素。DelayQueue是一个没有大小限制的队列,因此往队列中插入数据的操作(生产者)永远不会被阻塞,而只有获取数据的操作(消费者)才会被阻塞。
使用场景:DelayQueue使用场景较少,但都相当巧妙,常见的例子比如使用一个DelayQueue来管理一个超时未响应的连接队列。
DelayQueue阻塞的是其内部元素,DelayQueue中的元素必须实现 java.util.concurrent.Delayed接口,这个接口的定义非常简单:
public interface Delayed extends Comparable<Delayed> { long getDelay(TimeUnit unit);}
getDelay()方法的返回值就是队列元素被释放前的保持时间,如果返回0或者一个负值,就意味着该元素已经到期需要被释放,此时DelayedQueue会通过其take()方法释放此对象。
从上面Delayed 接口定义可以看到,它还继承了Comparable接口,这是因为DelayedQueue中的元素需要进行排序,一般情况,我们都是按元素过期时间的优先级进行排序。
例1:为一个对象指定过期时间
首先,我们先定义一个元素,这个元素要实现Delayed接口
import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;public class DelayedElement implements Delayed { //过期时间 private long expired; private long delay; private String name; public DelayedElement(String elementName, long delay) { this.name = elementName; this.delay= delay; this.expired = ( delay + System. currentTimeMillis()); } @Override public int compareTo(Delayed o) { //因为比较的DelayedElement类,所以必须先强制类型转换。 DelayedElement cached=(DelayedElement) o; //DelayedQueue中的元素需要进行排序,一般情况,我们都是按元素过期时间的优先级进行排序。 return cached.getExpired() > this.expired ? 1 : -1; } @Override public long getDelay(TimeUnit unit) { //过期时间减当前时间 (如果当前时间 到达 过期时间,该元素被释放) return ( expired - System. currentTimeMillis()); } @Override public String toString() { return "DelayedElement [delay=" + delay + ", name=" + name + "]"; } public long getExpired() { return expired; }}
public class Test { public static void main(String[] args) throws InterruptedException { DelayQueue<DelayedElement> queue = new DelayQueue<>(); //设置这个元素的过期时间为3s DelayedElement ele = new DelayedElement("cache 3 seconds", 3000); queue.put(ele); System.out.println(queue.take()); }}
运行这个main函数,我们可以发现,我们需要等待3s之后才会打印这个对象(toString())。
DelayedElement [delay=3000, name=cache 3 seconds]
其实DelayQueue应用场景很多,比如定时关闭连接、缓存对象,超时处理等各种场景,下面我们就拿学生考试为例让大家更深入的理解DelayQueue的使用。
例2:把所有考试的学生看做是一个DelayQueue,谁先做完题目释放谁
首先,我们构造一个学生对象
public class Student implements Runnable, Delayed { private String name; // 姓名 private long costTime;// 做试题的时间 private long finishedTime;// 完成时间 public Student(String name, long costTime) { this.name = name; this.costTime = costTime; finishedTime = costTime + System.currentTimeMillis(); } @Override public void run() { System.out.println(name + " 交卷,用时" + costTime / 1000); } @Override public long getDelay(TimeUnit unit) { return (finishedTime - System.currentTimeMillis()); } @Override public int compareTo(Delayed o) { Student other = (Student) o; return costTime >= other.costTime ? 1 : -1; }}
然后在构造一个教师对象对学生进行考试
public class Teacher { static final int STUDENT_SIZE = 30; public static void main(String[] args) throws InterruptedException { Random r = new Random(); // 把所有学生看做一个延迟队列 DelayQueue<Student> students = new DelayQueue<Student>(); // 构造一个线程池用来让学生们“做作业” ExecutorService exec = Executors.newFixedThreadPool(STUDENT_SIZE); for (int i = 0; i < STUDENT_SIZE; i++) { // 初始化学生的姓名和做题时间 students.put(new Student("学生" + (i + 1), 3000 + r.nextInt(10000))); } // 开始做题 while (!students.isEmpty()) { exec.execute(students.take()); } exec.shutdown(); }}
我们看一下运行结果:
学生4 交卷,用时3学生13 交卷,用时4学生5 交卷,用时5学生14 交卷,用时5学生2 交卷,用时5学生3 交卷,用时6学生26 交卷,用时6
通过运行结果我们可以发现,每个学生在指定开始时间到达之后就会“交卷”(取决于getDelay()方法),并且是先做完的先交卷(取决于compareTo()方法)。
4)PriorityBlockingQueue优先级对列
4.1 PriorityBlockingQueue是一个没有边界的队列,它的排序规则和 java.util.PriorityQueue一样。需要注意,PriorityBlockingQueue中允许插入null对象。
基于优先级的阻塞队列(优先级的判断通过构造函数传入的Compator对象来决定),但需要注意的是PriorityBlockingQueue并不会阻塞数据生产者,而只会在没有可消费的数据时,阻塞数据的消费者。因此使用的时候要特别注意,生产者生产数据的速度绝对不能快于消费者消费数据的速度,否则时间一长,会最终耗尽所有的可用堆内存空间。在实现PriorityBlockingQueue时,内部控制线程同步的锁采用的是公平锁。
4.2 所有插入PriorityBlockingQueue的对象必须实现 java.lang.Comparable接口,队列优先级的排序规则就是按照我们对这个接口的实现来定义的。
规则是:当前和其他对象比较,如果compare方法返回负数,那么在队列里面的优先级就比较高。
4.3 另外,我们可以从PriorityBlockingQueue获得一个迭代器Iterator,但这个迭代器并不保证按照优先级顺序进行迭代。
问题:有没有人在使用时,发现将添加在PriorityBlockingQueue的一系列元素打印出来,队列的元素其实并不是全部按优先级排序的,但是队列头的优先级肯定是最高的?
回复:PriorityBlockingQueue队列添加新元素时候不是将全部元素进行顺序排列。但是每取一个头元素时候,都会对剩余的元素做一次调整,这样就能保证每次队列头的元素都是优先级最高的元素
下面我们举个例子来说明一下,首先我们定义一个对象类型,这个对象需要实现Comparable接口:
public class PriorityElement implements Comparable<PriorityElement> { private int priority;// 定义优先级 public PriorityElement(int priority) { // 初始化优先级 this.priority = priority; } @Override public int compareTo(PriorityElement o) { // 按照优先级大小进行排序 return priority >= o.getPriority() ? 1 : -1; } public int getPriority() { return priority; } public void setPriority(int priority) { this.priority = priority; } @Override public String toString() { return "PriorityElement [priority=" + priority + "]"; }}
然后我们把这些元素随机设置优先级放入队列中
public class PriorityBlockingQueueExample { public static void main(String[] args) throws InterruptedException { PriorityBlockingQueue<PriorityElement> queue = new PriorityBlockingQueue<>(); for (int i = 0; i < 5; i++) { Random random = new Random(); PriorityElement ele = new PriorityElement(random.nextInt(10)); queue.put(ele); } while (!queue.isEmpty()) { System.out.println(queue.take()); } }}
看一下运行结果:
PriorityElement [priority=3]PriorityElement [priority=5]PriorityElement [priority=7]PriorityElement [priority=7]PriorityElement [priority=8]
5)SynchronousQueue
特殊的BlockingQueue,对其的操作必须是放和取交替完成的. 队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞,除非这个元素被另一个线程消费。
一种无缓冲的等待队列,类似于无中介的直接交易,有点像原始社会中的生产者和消费者,生产者拿着产品去集市销售给产品的最终消费者,而消费者必须亲自去集市找到所要商品的直接生产者,如果一方没有找到合适的目标,那么对不起,大家都在集市等待。相对于有缓冲的BlockingQueue来说,少了一个中间经销商的环节(缓冲区),如果有经销商,生产者直接把产品批发给经销商,而无需在意经销商最终会将这些产品卖给那些消费者,由于经销商可以库存一部分商品,因此相对于直接交易模式,总体来说采用中间经销商的模式会吞吐量高一些(可以批量买卖);但另一方面,又因为经销商的引入,使得产品从生产者到消费者中间增加了额外的交易环节,单个产品的及时响应性能可能会降低。
声明一个SynchronousQueue有两种不同的方式,它们之间有着不太一样的行为。公平模式和非公平模式的区别:
如果采用公平模式:SynchronousQueue会采用公平锁,并配合一个FIFO队列来阻塞多余的生产者和消费者,从而体系整体的公平策略;
但如果是非公平模式(SynchronousQueue默认):SynchronousQueue采用非公平锁,同时配合一个LIFO队列来管理多余的生产者和消费者,而后一种模式,如果生产者和消费者的处理速度有差距,则很容易出现饥渴的情况,即可能有某些生产者或者是消费者的数据永远都得不到处理。
学习链接:
http://blog.csdn.net/suifeng3051/article/details/48807423
http://www.cnblogs.com/liuling/p/2013-8-20-01.html
http://wsmajunfeng.iteye.com/blog/1629354
http://blog.sina.com.cn/s/blog_6145ed8101010q1y.html
- 学习阻塞队列BlockingQueue
- 阻塞队列(BlockingQueue)
- 阻塞队列BlockingQueue
- 阻塞队列 BlockingQueue
- BlockingQueue: 阻塞队列 接口
- 阻塞队列BlockingQueue
- 阻塞队列(BlockingQueue)
- 阻塞队列BlockingQueue使用方法
- 阻塞队列 BlockingQueue LinkedBlockingQueue
- Java 阻塞队列 BlockingQueue
- java 阻塞队列BlockingQueue
- 阻塞队列(BlockingQueue)
- 阻塞队列BlockingQueue
- 阻塞队列BlockingQueue
- 阻塞队列BlockingQueue
- 阻塞队列BlockingQueue
- 阻塞队列BlockingQueue
- 阻塞队列BlockingQueue用法
- C#中的扩展方法
- (个人)AR电子书创新系统实训第六周(2)
- 在Linux上安装Memcached服务
- sql server 循环脚本
- git push 使用
- 学习阻塞队列BlockingQueue
- where 和 having的区别
- 我的csdn
- GPUDirect and DirectGMA – direct GPU-GPU communication via RDMA
- Storm通信机制,Worker进程间通信,Worker进程间通信分析,Worker进程间技术(Netty、ZeroMQ),Worker 内部通信技术(Disruptor)(来自学习资料)
- 各种 starter poms (启动器)
- 报错PHP Warning: imagejpeg(): Filename cannot be empty in……
- POI 设置单元格背景颜色
- golang截取字符串