java阻塞队列的使用

最新推荐文章于 2024-01-10 14:37:36 发布

置顶小码哥(^_^)

最新推荐文章于 2024-01-10 14:37:36 发布

阅读量3.4k

点赞数 2

文章标签：阻塞队列使用

本文链接：https://blog.csdn.net/qq9808/article/details/105741599

版权

一.阻塞队列的作用

阻塞队列（BlockingQueue），顾名思义，首先它是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示：
在这里插入图片描述
当阻塞队列是空时，从队列中获取元素的操作将会被阻塞
当阻塞队列是满时，往队列中添加元素的操作将会被阻塞
同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他线程从队列中移除一个或者多个元素或者全清空队列后使队列重新变得空闲起来并后续新增

为什么需要使用BlockingQueue？好处是我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为BlockingQueue都一手给你包办好了。在concurrent包发布以前，多线程环境下，我们每个程序员都必须自己去控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。

更重要的是，线程池和阻塞队列息息相关，若想了解线程池底层原理，必须先了解阻塞队列。

二.阻塞队列的种类和方法

阻塞队列有主要以下几种：

ArrayBlockingQueue: 由数组结构组成的有界阻塞队列
LinkedBlockingDeque: 由链表结构组成的有界(但大小默认值Integer>MAX_VALUE)阻塞队列
PriorityBlockingQueue:支持优先级排序的无界阻塞队列
DelayQueue: 使用优先级队列实现的延迟无界阻塞队列
SynchronousQueue:不存储元素的阻塞队列,也即是单个元素的队列
LinkedTransferQueue:由链表结构组成的无界阻塞队列
LinkedBlockingDeque:由了解结构组成的双向阻塞队列

阻塞队列的核心方法有以下几组：
1.抛异常组：add()，remove()，element()；
2.返回布尔值组：offer()，poll()，peek()；
3.阻塞组：put()，take()；
4.超时组：offer()，poll()；

其中 add()、offer() 和 put() 方法都是向队列添加元素，remove()、poll()、take() 方法是从队列中取元素；element() 和 peek() 是查看队列内的元素。

各个组方法的说明如下：
1.抛异常组：当阻塞队列满时，再往队列里面 add 插入元素会抛异常 IllegalStateException: Queue full；当阻塞队列空时，再往队列 Remove 元素时候回抛出NoSuchElementException；
2.返回布尔值组：插入方法，成功返回true，失败返回false；移除方法，成功返回元素，队列里面没有就返回null
3.阻塞组：当阻塞队列满时，生产者继续往队列里面put元素，队列会一直阻塞直到 put 数据或响应中断退出；当阻塞队列空时，消费者试图从队列take元素，队列会一直阻塞消费者线程直到队列可用；
4.超时组：当阻塞队列满时，队列会阻塞生产者线程一定时间，超过后限时后生产者线程就会退出

下面对队列各个方法作举例说明
1.先看看add()方法， 代码如下：

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

public class BlockingQueueDemo {

    public static void main(String[] args) {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        System.out.println(blockingQueue.add("e"));

//        System.out.println(blockingQueue.element());   //返回队首元素

//        System.out.println(blockingQueue.remove());
//        System.out.println(blockingQueue.remove());
//        System.out.println(blockingQueue.remove());
//        System.out.println(blockingQueue.remove());
    }
}

先注释掉取元素的方法，运行一下结果如下：

Exception in thread “main” java.lang.IllegalStateException: Queue full
at java.util.AbstractQueue.add(AbstractQueue.java:98)
at java.util.concurrent.ArrayBlockingQueue.add(ArrayBlockingQueue.java:312)
at thread.BlockingQueueDemo.main(BlockingQueueDemo.java:16)
true
true
true

可以看出前面3个元素都能成功加入，但添加第4个元素的时候，由于超过了队列的长度，会抛出异常。
现在把取出元素的 remove() 的注释取消掉：

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

public class BlockingQueueDemo {

    public static void main(String[] args) {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
    }
}

执行并查看结果：

true
true
true
a
b
c
Exception in thread “main” java.util.NoSuchElementException
at java.util.AbstractQueue.remove(AbstractQueue.java:117)
at thread.BlockingQueueDemo.main(BlockingQueueDemo.java:22)

可以看出当队列为空时再往队列里面取出元素的话会抛出异常。
最后看看 element() 方法：

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

public class BlockingQueueDemo {

    public static void main(String[] args) {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

        System.out.println(blockingQueue.element());

        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
    }
}

执行结果：

true
true
true
a
a
b
c

注意，使用 element() 查看对首元素时，队列内的元素个数并不会减少。
那么如果队列为空时调用 element() 方法会怎么样呢：

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

public class BlockingQueueDemo {

    public static void main(String[] args) {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));

        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());

        System.out.println(blockingQueue.element());
    }
}

执行结果：

true
true
true
a
b
c
Exception in thread “main” java.util.NoSuchElementException
at java.util.AbstractQueue.element(AbstractQueue.java:136)
at thread.BlockingQueueDemo.main(BlockingQueueDemo.java:21)

当队列为空时调用 element() 方法也会抛出异常

2.看看 offer() 方法， 代码如下：

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

public class BlockingQueueDemo {

    public static void main(String[] args) {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("e"));
    }
}

执行结果：

true
true
true
false

由此可见当队列满了的时候，继续往里面添加元素会失败并返回 false
那么取出元素的时候呢？代码如下：

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

public class BlockingQueueDemo {

    public static void main(String[] args) {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
    }
}

执行结果：

true
true
true
a
b
c
null

当队列为空时，使用poll()方法取出元素会返回 null
最后看看 peek() 方法：

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

public class BlockingQueueDemo {

    public static void main(String[] args) {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));

        System.out.println(blockingQueue.peek());

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
    }
}

执行结果：

true
true
true
a
a
b
c

和 element() 方法类似，peek() 方法并不会使队列元素减少。

3.现在看看 put() 方法：

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

public class BlockingQueueDemo {

    public static void main(String[] args) throws InterruptedException {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        blockingQueue.put("d");
    }
}

运行之后发现程序程序会一直阻塞：
在这里插入图片描述
说明当队列满时，调用put方法会使队列一直阻塞，直到队列里面有空缺的位置。
然后再来看看 take() 方法：

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

public class BlockingQueueDemo {

    public static void main(String[] args) throws InterruptedException {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
    }
}

运行之后发现程序程序会一直阻塞：
在这里插入图片描述
说明当队列为空时，调用take方法取出队列会使程序一直阻塞下去，直到有新的元素加入队列中。

最后看看超时的情况，代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueDemo {

    public static void main(String[] args) throws InterruptedException {

        //创建一个长度为3的阻塞队列
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

        System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));
        System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));
        System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));
        System.out.println(blockingQueue.offer("a",2L, TimeUnit.SECONDS));
    }
}

执行结果如下：

true
true
true
false

当往队列里面添加第4个"a"时，由于队列已经满了，程序会在超时2秒之后插入失败并返回false

以上就是阻塞队列的主要方法的演示。

三.阻塞队列的应用

阻塞队列可以应用于生产者/消费者问题上，代码如下：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ProdConsBlockQueueDemo {
    public static void main(String[] args) {
        MyResource myResource = new MyResource(new ArrayBlockingQueue<>(10));
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t生产线程启动");
            try {
                myResource.myProd();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "prod").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t消费线程启动");
            try {
                myResource.myCons();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "cons").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("5秒钟后，叫停");
        myResource.stop();
    }
}

class MyResource {
    private volatile boolean FLAG = true; //默认开启，进行生产+消费
    private AtomicInteger atomicInteger = new AtomicInteger();

    private BlockingQueue<String> blockingQueue;

    public MyResource(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public void myProd() throws Exception {
        String data = null;
        boolean retValue;
        while (FLAG) {
            data = atomicInteger.incrementAndGet() + "";//++i
            retValue = blockingQueue.offer(data, 2L, TimeUnit.SECONDS);
            if (retValue) {
                System.out.println(Thread.currentThread().getName() + "\t" + "插入队列" + data + "成功");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t" + "插入队列" + data + "失败");
            }
            TimeUnit.SECONDS.sleep(1);
        }
        System.out.println(Thread.currentThread().getName() + "\tFLAG==false，停止生产");
    }

    public void myCons() throws Exception {
        String res;
        while (FLAG) {
            res = blockingQueue.poll(2L, TimeUnit.SECONDS);
            if (null == res || res.equalsIgnoreCase("")) {
                FLAG = false;
                System.out.println(Thread.currentThread().getName() + "\t超过2秒钟没有消费，退出消费");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "\t消费队列" + res + "成功");
        }
    }

    public void stop() {
        this.FLAG = false;
    }
}

执行结果：

cons	消费线程启动
prod	生产线程启动
prod	插入队列1成功
cons	消费队列1成功
cons	消费队列2成功
prod	插入队列2成功
prod	插入队列3成功
cons	消费队列3成功
prod	插入队列4成功
cons	消费队列4成功
prod	插入队列5成功
cons	消费队列5成功
5秒钟后，叫停
prod	FLAG==false，停止生产
cons	超过2秒钟没有消费，退出消费

使用阻塞队列来解决生产者/消费者问题的时候，不再需要进行同步处理，这种思想在消息队列中有着广泛的应用。

小码哥(^_^)

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
java阻塞队列的使用

1.阻塞队列的作用阻塞队列（BlockingQueue），顾名思义，首先它是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示：当阻塞队列是空时，从队列中获取元素的操作将会被阻塞当阻塞队列是满时，往队列中添加元素的操作将会被阻塞同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他线程从队列中移除一个或者多个元素或者全清空队列后使队列重新变得空闲起来并后续新增为什...
复制链接

扫一扫