Java阻塞队列

最新推荐文章于 2024-07-29 21:55:07 发布
最新推荐文章于 2024-07-29 21:55:07 发布
阅读量387 收藏
点赞数
分类专栏： java基础 文章标签： Java阻塞队列 BlockingQueue 阻塞队列实现生消问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sltylzx/article/details/90255858
版权

参考：

http://ifeve.com/blocking-queues/

https://blog.csdn.net/bohu83/article/details/80784891

1.阻塞队列

[1].当阻塞队列是空时，从队列中获取元素的操作将会被阻塞，直到其他线程往里面插入新的元素

[2].当阻塞队列是满时，往队列里添加元素的操作将会被阻塞，直到其他线程从队列里移除一个或多个或者完全清空再继续添加

2.好处

[1].在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒

[2].使用BlockingQueue的好处

我们不在需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue都处理好了，在concurrent包发布前，在多线程环境下，程序员需要手动控制这些细节，还有兼顾安全和效率

3.架构体系

[1].ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。

[2].LinkedBlockingQueue ：一个由链表结构组成的有界（但大小默认值为Integer.MAX_VALUE）阻塞队列。

[3].PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。

[4].DelayQueue：一个使用优先级队列实现的无界阻塞队列。

[5].SynchronousQueue：一个不存储元素的阻塞队列，也即单个元素的队列。

[6].LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。

[7].LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列

4.常用方法

方法\处理方式

抛出异常

返回特殊值

一直阻塞

超时退出

插入方法

add(e)

offer(e)

put(e)

offer(e,time,unit)

移除方法

remove()

poll()

take()

poll(time,unit)

检查方法

element()

peek()

不可用

不可用

[1].抛出异常：

①.是指当阻塞队列满时候，再往队列里插入元素，会抛出IllegalStateException(“Queue full”)异常。

②.当队列为空时，从队列里获取元素时会抛出NoSuchElementException异常 。

package com.w4xj.interview.thread;



import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;



/**

* @Author by w4xj

* @Classname ThrowExceptionBlockingQueueFunction

* @Description TODO

* @Date 2019/5/8 12:58

* @Created by IDEA

*/

public class ThrowExceptionBlockingQueueMethod {

    public static void main(String[] args) {

        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);



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

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

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

        //Exception in thread "main" java.lang.IllegalStateException: Queue full

        //System.out.println(blockingQueue.add("z"));

        //队列头元素

        blockingQueue.element();



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

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

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

        //java.util.NoSuchElementException

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

    }

}

[2].返回特殊值：

①.插入方法会返回是否成功，成功则返回true。

②.移除方法，则是从队列里拿出一个元素，如果没有则返回null

package com.w4xj.interview.thread;





import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;



/**

* @Author by w4xj

* @Classname ReturnSpecialValueBlockingQueueMethod

* @Description TODO

* @Date 2019/5/8 20:05

* @Created by IDEA

*/

public class ReturnSpecialValueBlockingQueueMethod {

    public static void main(String[] args) {

        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("z"));

        System.out.println("-----------------------------------------");

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

        System.out.println("-----------------------------------------");

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

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

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

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



        /*

        打印：

            true

            true

            true

            false

            -----------------------------------------

            a

            -----------------------------------------

            a

            b

            c

            null

         */

    }

}

[3].一直阻塞：

①.当阻塞队列满时，如果生产者线程往队列里put元素，队列会一直阻塞生产者线程，直到拿到数据，或者响应中断退出。

②.当队列空时，消费者线程试图从队列里take元素，队列也会阻塞消费者线程，直到队列可用。

[4].超时退出：

①.当阻塞队列满时，队列会阻塞生产者线程一段时间，

②.如果超过一定的时间，生产者线程就会退出。

package com.w4xj.interview.thread;



import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.TimeUnit;



/**

* @Author by w4xj

* @Classname TimeBlockingQueue

* @Description TODO

* @Date 2019/5/8 20:19

* @Created by IDEA

*/

public class TimeBlockingQueue {

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

        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

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

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

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

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

        /*

        打印：

            true

            true

            true

            false

         */

    }

}

5.SynchronousQueue

[1].SynchronousQueue没有容量，与其他BlockingQueue不同，SynchronousQueue是一个不存储元素的SynchronousQueue。没一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然

[2].代码示例

package com.w4xj.interview.thread;



import java.util.concurrent.BlockingQueue;

import java.util.concurrent.SynchronousQueue;

import java.util.concurrent.TimeUnit;



/**

* @Author by w4xj

* @Classname SynchronousQueueTest

* @Description TODO

* @Date 2019/5/8 20:37

* @Created by IDEA

*/

public class SynchronousQueueTest {

    public static void main(String[] args) {

        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();



        new Thread(() ->{

            try {

                System.out.println(Thread.currentThread().getName() + " put a");

                blockingQueue.put("a");



                System.out.println(Thread.currentThread().getName() + " put b");

                blockingQueue.put("b");



                System.out.println(Thread.currentThread().getName() + " put c");

                blockingQueue.put("c");

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        },"ThreadA").start();



        new Thread(() ->{

            try {

                //线程睡1秒

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

                System.out.println(Thread.currentThread().getName() + " get " + blockingQueue.take());



                //线程睡1秒

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

                System.out.println(Thread.currentThread().getName() + " get " + blockingQueue.take());



                //线程睡1秒

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

                System.out.println(Thread.currentThread().getName() + " get " + blockingQueue.take());

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        },"ThreadB").start();



        /*

        打印：

            ThreadA put a

            ThreadB get a

            ThreadA put b

            ThreadB get b

            ThreadA put c

            ThreadB get c

         */

    }

}

6.生产消费者

[1].使用synchronized

[2].使用Lock（Lock和synchronized的对比，见Java锁）

package com.w4xj.interview.thread;



import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;



/**

* @Author by w4xj

* @Classname ProducerConsumerTraditional

* @Description TODO

* @Date 2019/5/8 22:14

* @Created by IDEA

*/

public class ProducerConsumerTraditional {

    public static void main(String[] args) {

        /*

        线程操作资源类

        判断干活唤醒

        防止虚假唤醒

         */

        Resource resource = new Resource();

        new Thread(() ->{

            try {

                 for (int i = 0; i < 5; i++) {

                     resource.increment();

                 }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        },"ThreadA").start();





        new Thread(() ->{

            try {

                 for (int i = 0; i < 5; i++) {

                     resource.decrement();

                 }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        },"ThreadB").start();





        /*

        打印：

            ThreadA    1

            ThreadB    0

            ThreadA    1

            ThreadB    0

            ThreadA    1

            ThreadB    0

            ThreadA    1

            ThreadB    0

            ThreadA    1

            ThreadB    0

         */

    }

}





class Resource{

    private int number = 0;

    private Lock lock = new ReentrantLock();

    Condition condition = lock.newCondition();

    public void increment() throws InterruptedException {

        lock.lock();

        try {

            //while防止虚假唤醒

            while (number != 0) {

                condition.await();

            }

            number++ ;

            System.out.println(Thread.currentThread().getName() + "\t" + number);

            condition.signalAll();

        }catch (Exception e){

            e.printStackTrace();

        }finally {

            lock.unlock();

        }

    }



    public void decrement() throws InterruptedException {

        lock.lock();

        try {

            //while防止虚假唤醒

            while (number == 0) {

                condition.await();

            }

            number-- ;

            System.out.println(Thread.currentThread().getName() + "\t" + number);

            condition.signalAll();

        }catch (Exception e){

            e.printStackTrace();

        }finally {

            lock.unlock();

        }

    }

}

[3].使用阻塞队列

package com.w4xj.interview.thread;



import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;



/**

* @Author by w4xj

* @Classname ProducerConsumerBlockingQueue

* @Description TODO

* @Date 2019/5/10 7:38

* @Created by IDEA

*/

public class ProducerConsumerBlockingQueue {

    public static void main(String[] args) {

        CakeResouce cakeResouce = new CakeResouce(new ArrayBlockingQueue<String>(3));



        new Thread(() ->{

            try {

                cakeResouce.produce();

            } catch (Exception e) {

                e.printStackTrace();

            }

        },"prodcuder").start();



        new Thread(() ->{

            try {

                cakeResouce.consume();

            } catch (Exception e) {

                e.printStackTrace();

            }

        },"consumer").start();



        //线程睡1秒

        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }



        cakeResouce.stopProduce();

        /*

        打印：

            prodcuder  生产1成功

            consumer   消费1成功

            consumer   消费2成功

            prodcuder  生产2成功

            consumer   消费3成功

            prodcuder  生产3成功

            prodcuder  生产4成功

            consumer   消费4成功

            prodcuder  生产5成功

            consumer   消费5成功

            main    嘿，停止生产了~~

            prodcuder   停止生产

            consumer   两秒钟未能成功消费,退出

            consumer    停止消费

         */



    }

}



class CakeResouce{

    /**

     * 线程执行标志

     * true：执行

     * false：停止

     */

    private volatile boolean currentFlag = true;



    private AtomicInteger atomicInteger = new AtomicInteger();



    private BlockingQueue<String> blockingQueue = null;





    /**

     * 构造时传入队列实例

     * @param blockingQueue

     */

    public CakeResouce(BlockingQueue<String> blockingQueue) {

        this.blockingQueue = blockingQueue;

    }



    /**

     * 生产

     * @throws Exception

     */

    public void produce() throws Exception{

        String data ;

        while (currentFlag){

            data = String.valueOf(atomicInteger.incrementAndGet());

            boolean offer = blockingQueue.offer(data, 2L, TimeUnit.SECONDS);

            if(offer){

                System.out.println(Thread.currentThread().getName() + " \t生产" + data + "成功");

            }else {

                System.out.println(Thread.currentThread().getName() + " \t生产" + data + "失败");

            }

            //线程睡400ms

            try { TimeUnit.MILLISECONDS.sleep(400); } catch (InterruptedException e) { e.printStackTrace(); }

        }

        System.out.println(Thread.currentThread().getName() + "\t 停止生产");

    }



    /**

     * 消费

     * @throws Exception

     */

    public void consume() throws Exception{

        String data ;

        while (currentFlag){

            String poll = blockingQueue.poll(2L, TimeUnit.SECONDS);

            if(null != poll && !"".equalsIgnoreCase(poll)){

                System.out.println(Thread.currentThread().getName() + " \t消费" + poll + "成功");

            }else {

                currentFlag = false;

                System.out.println(Thread.currentThread().getName() + " \t两秒钟未能成功消费,退出");

            }

            //线程睡100毫秒，防止消费x打印在生产x之前

            try { TimeUnit.MILLISECONDS.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); }

        }



        System.out.println(Thread.currentThread().getName() + "\t 停止消费");

    }



    /**

     * 停止生产

     */

    public void stopProduce(){

        currentFlag = false;

        System.out.println(Thread.currentThread().getName() + "\t 嘿，停止生产了~~");

    }



}

 

 

 

 

 

 

 

 

w4xj
关注
专栏目录
让人一看就会的java阻塞队列与非阻塞队列
m0_73533108的博客
09-04 906
今天要来讲一下java里的队列，队列，顾名思义，排队的列，既然按排队形来做的话，生活中的银行排队啊，上车排队啊，都是先到先办理或者先上车，队列存取数据列也一样，这就是先进先出，使用队列的规则是：使用队素时，数据元素只能从表的一端进入队列，另一端出队列。
剖析Java中阻塞队列的实现原理及应用场景
09-03
Java中的阻塞队列是一种特殊的线程安全的数据结构，它在多线程环境下用于高效地处理生产者-消费者问题。阻塞队列的核心特性在于当队列为空时，尝试获取元素的线程会被阻塞，直到队列中有元素可用；同样，当队列满时...
Java实现简单的阻塞队列2种方式
06-10
Java实现简单的阻塞队列2种方式，1使用wait()，notify();2使用countdownlatch实现
【Java】阻塞队列
Creativity + Efficiency = Success
03-06 1314
介绍阻塞队列的定义、种类、实现原理以及应用。
JavaEE 初阶（11）——多线程9之“阻塞队列”
最新发布
2301_80243321的博客
07-29 2290
本篇主要是一些“阻塞队列”的相关知识，讲解了阻塞队列在“生产者消费者模型”中的应用
java阻塞队列
shiralwz的专栏
04-12 299
JDK7提供了7个阻塞队列。分别是ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。DelayQueue：一个使用优先级队列实现的无界阻塞队列。SynchronousQueue：一个不存储元素的阻塞队列。LinkedTr...
Java 中的阻塞队列
weixin_52383177的博客
09-21 2182
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取元素的容器。
BlockingQueu 阻塞队列
dizan4060的博客
09-14 296
java.util.concurrent public interface BlockingQueue<E> extends Queue<E> 简介 当阻塞队列插入数据时： 如果队列已经满了，线程则会阻塞等待队列中元素被取出后在插入。 当从阻塞队列中取数据时，如果队列是空的，则线程会阻塞等待队列中有新元素。 阻塞队列（BlockingQueue...
java阻塞队列实现原理及实例解析
08-25
Java阻塞队列实现原理及实例解析 Java阻塞队列是一种特殊的队列，它能够在队列为空或满时阻塞线程，使得线程之间能够更好地协作和通信。阻塞队列的实现原理是基于锁机制和条件变量机制的，通过wait和notify方法来...
Java阻塞队列四组API介绍(小结)
08-19
Java阻塞队列四组API介绍 Java阻塞队列四组API介绍是Java并发编程中非常重要的一部分，本文将详细介绍这四组API，并通过示例代码进行讲解。 第一组API：会抛出异常的API 第一组API包括add()、remove()、element()...
详解Java阻塞队列(BlockingQueue)的实现原理
08-30
"详解Java阻塞队列(BlockingQueue)的实现原理" Java阻塞队列（BlockingQueue）是Java.util.concurrent包下重要的数据结构，提供了线程安全的队列访问方式。BlockingQueue的实现原理主要是基于四组不同的方法用于...
Java中的阻塞队列
uk8692的专栏
06-26 359
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。1、支持阻塞的插入方法：当队列满时，队列会阻塞插入元素的线程，直到队列不满。2、支持阻塞的移除方法：在队列为空时，获取元素的线程会等待队列变为非空。阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。阻塞队列就是生产者用来存放元素、消费者用来获取
java之阻塞队列（BlockingQueue）
weixin_43824267的博客
01-22 2611
java之阻塞队列一、阻塞队列概念二、阻塞队列的好处三、阻塞队列种类四、BlockingQueue的核心方法五、示例代码1.使用SychronousQueue队列2.传统版生产者消费者模式3.阻塞队列版（以ArrayBlockingQueue为例）生产者消费者模式 一、阻塞队列概念 阻塞队列，顾名思义，首先它是一个队列（先进先出），而一个阻塞队列在数据结构所起到的作用大致如下图： 线程1往阻塞队列中添加元素，而线程2从阻塞队列中移除元素 当阻塞队列是空是，从队列中获取元素的操作会被阻塞 当阻塞队列是满时
java中的阻塞队列
小海子的博客
06-14 348
前言 在去年的面试过程中，被面试官问道“阻塞队列”这个问题，因为当时并没有对此问题进行深入理解，只是按照自己的理解说明了该问题，最后面试结果也不太好，今天对该问题进行简要的面试并记录如下；如有错误，欢迎指正。 什么是阻塞队列 在数据结构中，队列遵循FIFO（先进先出）原则。在java中，Queue接口定义了定义了基本行为，由子类完成实现，常见的队列有ArrayDeque、LinkedList等，这些都是非线程安全的，在java 1.5中新增了阻塞队列，当队列满时，添加元素的线程呈阻塞状态；当队列为空时，获取
阻塞队列 java例子_java阻塞队列实现原理及实例解析
weixin_33170268的博客
02-17 252
这篇文章主要介绍了java阻塞队列实现原理及实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下阻塞队列与普通队列的不同在于。当队列是空的时候，从队列中获取元素的操作将会被阻塞，或者当队列满时，往队列里面添加元素将会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素...
Java阻塞队列四组API详解：异常与阻塞策略
"Java阻塞队列四组API的详细解析" Java阻塞队列是Java并发编程中重要的一部分，它提供了线程安全的数据结构，用于在生产者和消费者之间传递数据。Java阻塞队列提供了四组主要的API，它们在处理元素的添加、移除和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值