JUC——阻塞队列

2018-06-18 00:27:32来源：未知阅读 ()

Queue是一个队列，而队列的主要特征是FIFO先进先出，要实现生产者与消费者模型，也可以采用队列来进行中间的缓冲读取，好处是：生产者可以一直不停歇的生产数据。

BlockingQueue是Queue的子类，它实现有队列的基本特征：

public interface BlockingQueue<E> extends Queue<E>

在最初利用Queue实现生产者与消费者模型的时候发现一个问题：所有的消费者可能不是一个轮流操作，而是有可能某一个消费者长期进行消费处理。

阻塞队列

BlockingQueue通常用于一个线程生成对象，而另外一个线程消费这些对象的场景。

　　一个线程将会持续生成新对象并将其插入到队列之中，直到队列达到它所能容纳的临界点，也就是说，它是有限的。如果该阻塞队列到达了临界点，负责生产的线程将会再往里面插入新对象时发生阻塞。它会一直处于阻塞之中，直到负责消费的线程从队列中拿走一个对象。

BlockingQueue也是一个处理接口，如果要想操作BlockingQueue也需要使用它的一系列子类：

对于阻塞队列而言最基础的两个实现子类：数组的队列，链表的队列。

范例：使用BlockingQueue实现一个消费者与生产者模型

package so.strong.mall.concurrent;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class QueueDemo {
    public static void main(String[] args) {
        final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(5);//允许保存5个数据队列
        for (int i = 0; i < 3; i++) { //3个生产者
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 5; j++) {
                        try {
                            TimeUnit.SECONDS.sleep(j);
                            String str = "[生产数据{" + Thread.currentThread().getName() + "}] j = " + j;
                            queue.put(str); //会进入到生产的阻塞状态
                            System.out.println(str);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "生产者-" + i).start();
        }

        for (int i = 0; i < 5; i++) {  //5个消费者
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            TimeUnit.SECONDS.sleep(2);
                            if (queue.isEmpty()) { //队里内容为空
                                break;
                            }
                            System.out.println("[消费数据{" + Thread.currentThread().getName() + "}]" + queue.take());
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "消费者-" + i).start();

        }
    }
}

除了数组之外也可以使用链表来进行操作：LinkedBlockingQueue。在使用这个类进行BlockingQueue接口对象实例化的时候，如果没有设置容量，则容量为：Integer.MAX_VALUE。

范例：修改为链表实现消费者与生产者模型

final BlockingQueue<String> queue = new LinkedBlockingQueue<>(5);//允许保存5个数据队列

链表是通过索引在进行弹出数据的，而链表只需要弹出第一个元素即可。

范例：采用优先级的PriorityBlockingQueue来实现数据操作

public class PriorityBlockingQueue<E> extends AbstractQueue<E>
    implements BlockingQueue<E>, java.io.Serializable

PriorityBlockingQueue利用了Comparable接口来进行处理完成。

final BlockingQueue<String> queue = new PriorityBlockingQueue<>(5);//允许保存5个数据队列

对于使用哪一种具体的子类完全是由具体的开发环境来决定的。需要至少知道BlockingQueue这个阻塞队列核心就是提供有同步队列的功能。

SychronousQueue同步队列

之前使用的BlockingQueue每一次都可以保存多个数据对象信息，但是有些时候只能够允许保存一个数据的信息，这种情况下就要使用SychronousQueue子类来完成、

范例：使用同步队列来进行处理

package so.strong.mall.concurrent;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

public class QueueDemo {
    public static void main(String[] args) {
        final BlockingQueue<String> queue = new SynchronousQueue<>();//允许保存5个数据队列
        for (int i = 0; i < 3; i++) { //3个生产者
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 5; j++) {
                        try {
                            TimeUnit.SECONDS.sleep(j);
                            String str = "[生产数据{" + Thread.currentThread().getName() + "}] j = " + j;
                            queue.put(str); //会进入到生产的阻塞状态
                            System.out.println(str);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "生产者-" + i).start();
        }

        for (int i = 0; i < 5; i++) {  //5个消费者
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            TimeUnit.SECONDS.sleep(2);
                            System.out.println("[消费数据{" + Thread.currentThread().getName() + "}]" + queue.take());
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "消费者-" + i).start();
        }
    }
}

现在不关心有多少个消费者与生产者，都采用一个接一个的形式执行。

BlockingDeque双端阻塞队列

BlockingQueue主要特征是只能够从一方面获取数据，也就是说它按照一个队列的形式采用了FIFO处理完成。但是现在希望可以按照前后各自处理，那么就需要BlocingDeque。

一个BlockingDeque线程在双端队列的两端都可以插入数据和提取数据。

一个线程生产元素，并把它们插入到队列的任意一端。如果双端队列已满，插入线程将被阻塞，直到一个移除线程从该队列中移除了一个元素。如果双端队列为空，移除线程将被阻塞，直到一个插入线程向该队列插入了一个新元素。

BlockingDeque接口结构：

public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E>

子类LinkedBlockingDeque类结构

public class LinkedBlockingDeque<E> extends AbstractQueue<E> implements BlockingDeque<E>,  java.io.Serializable

范例：观察双端队列的基本使用

package so.strong.mall.concurrent;

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;

/**
 * @author Termis
 * @date 2018/5/21
 */
public class QueueDemo {
    public static void main(String[] args) {
        final BlockingDeque<String> deque = new LinkedBlockingDeque<>();
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 5; j++) {
                        try {
                            TimeUnit.SECONDS.sleep(1);
                            String str;
                            if (j % 2 == 0) {
                                str = "[FIRST]生产数据{" + Thread.currentThread().getName() + "}y=" + j;
                                deque.addFirst(str);
                            } else {
                                str = "[LAST]生产数据{" + Thread.currentThread().getName() + "}y=" + j;
                                deque.addLast(str);
                            }
                            System.out.println(str);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "生产者-" + i).start();
        }

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        TimeUnit.SECONDS.sleep(2);
                        System.out.println("[First]消费数据{" + Thread.currentThread().getName() + "}" + deque.takeFirst());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "消费者First").start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        TimeUnit.SECONDS.sleep(2);
                        System.out.println("[Last]消费数据{" + Thread.currentThread().getName() + "}" + deque.takeLast());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "消费者Last").start();

    }
}

生产者和消费者模型的实现方案很多。对于双端队列一定清楚它本身还是一个队列。如果现在first已经拽干净了，那么就继续拽last，就会有可能出现first消费last的情况。

public class QueueDemo {
    public static void main(String[] args) throws Exception {
        BlockingDeque<String> deque = new LinkedBlockingDeque<>();
        deque.addFirst("hello-first");
        deque.addFirst("world-first");
        deque.addLast("hello-last");
        deque.addLast("world-last");
        System.out.println(deque.takeFirst());
        System.out.println(deque.takeFirst());
        System.out.println(deque.takeFirst());
        System.out.println(deque.takeFirst());
    }
}

world-first
hello-first
hello-last
world-last

如果一端出现了阻塞，那么至少另外一端可以继续使用。

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：Java 中的伪共享详解及解决方案

下一篇：Java学习笔记十三:Java中的类和对象

IDC资讯：主机资讯注册资讯托管资讯 vps资讯网站建设

网站运营：建站经验策划盈利搜索优化网站推广免费资源

网站联盟：联盟新闻联盟介绍联盟点评网赚技巧

行业资讯：搜索引擎网络游戏电子商务广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器安全防护

软件技巧：其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识：网络协议网络安全网络管理组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条

最新资讯

热门关注

热门标签