阻塞队列——BlockingQueue

最新推荐文章于 2025-06-01 15:18:59 发布
原创 最新推荐文章于 2025-06-01 15:18:59 发布 · 559 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#阻塞队列
本文介绍阻塞队列的基本概念及其与普通队列的主要区别，并通过两种不同的实现方式来展示阻塞队列的工作机制：一种是使用wait和notifyAll方法，另一种是利用ReentrantLock和Condition条件变量。

阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从队列中移除一个或者多个元素，或者完全清空队列。

wait、notifyAll实现方式
package blocks;

import java.util.ArrayList;

/**
 * Created by maxi on 2017/11/8.
 */
public class ObjectBlockQueues<E> implements BlockQueues<E> {
    private final ArrayList<E> lists;
    private int limite;
//    private ReentrantLock mLocks;

    public ObjectBlockQueues() {
        this(10, false);
    }

    public ObjectBlockQueues(int limite) {
        this(limite, false);
    }

    public ObjectBlockQueues(int limite, Boolean isFair) {
        this.limite = limite;
        lists = new ArrayList<E>(limite);
//        mLocks = new ReentrantLock(isFair);
    }

    @Override
    public synchronized E get(int index) {
//        final ReentrantLock mLocks = this.mLocks;
//        mLocks.lock();
        E e = this.lists.get(index);
//        mLocks.unlock();
        return e;
    }

    @Override
    public void add(E e) {
        checkNotNull(e);
//        final ReentrantLock mLocks = this.mLocks;
//        mLocks.lock();
        synchronized(this.lists) {
            try {
                while (this.lists.size() == this.limite) {
//                    System.out.println("============" + e + " will wait =============");
                    this.lists.wait();
//                    System.out.println("============" + e + " is break! =============");
                }
                if (this.lists.size() == 0) {
//                    System.out.println("============add " + e + " notifyAll =============");
                    this.lists.notifyAll();
                }
                this.lists.add(e);
            } catch (Exception e1) {
                e1.printStackTrace();
            } finally {
//            mLocks.unlock();
            }
        }
    }

    @Override
    public void remove(E e) {
        checkNotNull(e);
//        final ReentrantLock mLocks = this.mLocks;
//        mLocks.lock();
        synchronized(this.lists) {
            try {
                while (this.lists.size() == 0) {
                    this.lists.wait();
                }
                if (this.lists.size() == this.limite) {
//                    System.out.println("============remove " + e + " notifyAll =============");
                    this.lists.notifyAll();
                }
                this.lists.remove(e);
            } catch (Exception e1) {
                e1.printStackTrace();
            } finally {
//            mLocks.unlock();
            }
        }
    }

    @Override
    public synchronized void removeAll() {
//        final ReentrantLock mLocks = this.mLocks;
//        mLocks.lock();
        this.lists.clear();
//        mLocks.unlock();
    }

    @Override
    public int size() {
//        final ReentrantLock mLocks = this.mLocks;
//        mLocks.lock();
        synchronized(this.lists) {
            int length = this.lists.size();
//        mLocks.unlock();
            return length;
        }
    }

    private static void checkNotNull(Object v) {
        if (v == null)
            throw new NullPointerException();
    }
}
锁的实现方式
package blocks;

import java.util.ArrayList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by maxi on 2017/11/8.
 */
public class ArrayBlockQueue<E> implements BlockQueues<E> {
    private final ArrayList<E> lists;
    private int limite;
    private ReentrantLock mLocks;
    private Condition notEmpty;
    private Condition notFull;

    public ArrayBlockQueue() {
        this(10, false);
    }

    public ArrayBlockQueue(int limite) {
        this(limite, false);
    }

    public ArrayBlockQueue(int limite, Boolean isFair) {
        this.limite = limite;
        lists = new ArrayList<>();
        mLocks = new ReentrantLock(isFair);
        notEmpty = mLocks.newCondition();
        notFull = mLocks.newCondition();
    }

    @Override
    public E get(int index) {
        final ReentrantLock mLocks = this.mLocks;
        mLocks.lock();
        E e = this.lists.get(index);
        mLocks.unlock();
        return e;
    }

    @Override
    public void add(E e) {
        checkNotNull(e);
//        final ReentrantLock mLocks = this.mLocks;
        mLocks.lock();
        try {
            while (this.lists.size() == this.limite) {
//                    System.out.println("============" + e + " will wait =============");
                notFull.await();
//                    System.out.println("============" + e + " is break! =============");
            }
//            if (this.lists.size() == 0) {
////                    System.out.println("============add " + e + " notifyAll =============");
//                this.lists.notifyAll();
//            }
            this.lists.add(e);
            notEmpty.signalAll();
        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            mLocks.unlock();
        }
    }

    @Override
    public void remove(E e) {
        checkNotNull(e);
//        final ReentrantLock mLocks = this.mLocks;
        mLocks.lock();
        try {
            while (this.lists.size() == 0) {
//                    this.lists.wait();
                notEmpty.await();
            }
//                if (this.lists.size() == this.limite) {
////                    System.out.println("============remove " + e + " notifyAll =============");
//                    this.lists.notifyAll();
//                }
            this.lists.remove(e);
            notFull.signalAll();
        } catch (Exception e1) {
            e1.printStackTrace();
        } finally {
            mLocks.unlock();
        }
    }

    @Override
    public synchronized void removeAll() {
//        final ReentrantLock mLocks = this.mLocks;
        mLocks.lock();
        this.lists.clear();
        mLocks.unlock();
    }

    @Override
    public int size() {
//        final ReentrantLock mLocks = this.mLocks;
        mLocks.lock();
        int length = this.lists.size();
        mLocks.unlock();
        return length;
    }

    private static void checkNotNull(Object v) {
        if (v == null)
            throw new NullPointerException();
    }
}
main函数
package blocks;

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

/**
 * Created by maxi on 2017/11/8.
 */
public class BlockMain {
    public static void main(String[] args) throws InterruptedException {
//        BlockQueues<String> blockQueues = new ObjectBlockQueues<>();
        BlockingQueue<String> blockingQueues = new ArrayBlockingQueue<String>(10);
        BlockQueues<String> blockQueues = new ArrayBlockQueue<String>(10);
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i <= 20; i++) {
//                try {
//                    Thread.sleep(1000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                blockQueues.add("num" + i);
                System.out.println("thread 1 add " + i + " queue size = " + blockQueues.size());
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i <= 20; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                blockQueues.remove("num" + i);
                System.out.println("thread 2 remove " + i + " queue size = " + blockQueues.size());
            }
        });


        thread1.start();
        thread2.start();


    }
}
JUC——阻塞队列
weixin_51020122的博客
05-08 506
什么是阻塞队列 Concurrent 包中，BlockingQueue 很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了 BlockingQueue 家庭中的所有成员，包括他们各自的功能以及常见使用场景。阻塞队列，顾名思义，首先它是一个队列, 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出； 当队列是空的，从队列中获取元素的操作将会被阻塞 当队列是满的，从队列中添加元素的操作将会被阻塞
阻塞队列BlockingQueue(FIFO)
weixin_41987908的博客
06-01 872
BlockingQueue接口与Queue接口【Queue 和 BlockingQueue 都是在 Java 5 中加入的】
BlockingQueue深入解析之一DelayQueue
qq_41030039的博客
09-24 1144
1、初识阻塞队列 在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 BlockingQueue的核心方法： public interface Blocking...
BlockingQueue(阻塞队列)
Student111w的博客
07-19 7832
BlockingQueue 阻塞队列（BlockingQueue） 是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。 使用场景： 多线程并发处理，线程池！ 队列 FIFO先进先出 一端写入一端取出 写入如果队列满了就必须阻塞等待 如果队列是空的必须阻塞等待
阻塞队列（BlockingQueue）
qq_43390704的博客
09-27 591
线程池、连接池、内存池、对象池 jdbc的连接和关闭是非常1耗费资源了 池化技术∶事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。 线程池的好处 1，降低了资源的消耗，提高响应的速度，方便管理 ...
BlockingQueue（阻塞队列）详解
maguanghui_2012的专栏
07-12 395
注意：该随笔内容完全引自http://wsmajunfeng.iteye.com/blog/1629354，写的很好，非常感谢，复制过来算是个积累，怕以后找不到。一. 前言　　在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了Blockin...
阻塞队列BlockingQueue
我能在河边钓一整天的鱼
06-01 861
目录 什么是阻塞队列 阻塞队列家族 阻塞队列的4种常用API 同步队列SynchronousQueue 什么是阻塞队列 队列是先进先出的。如果队列满了，新元素想进来不得不阻塞。如果队列是空的，想取出队列中的元素也不得不阻塞 阻塞队列广泛应用在线程池技术和各种消息队列中间件的底层中~ 阻塞队列家族 阻塞队列家族属于Clollection集合的成员，Queue与Set和List是平级 阻塞队列的4种常用API 第一...
阻塞队列BlockingQueue解析
最新发布
qq_65779957的博客
06-01 1103
阻塞队列是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除的方法。抛出异常：当队列满时候插入元素的时候则会直接抛出异常，为空时取出元素也会抛出元素。返回特殊值：这种方式不会阻塞线程而是直接返回boolean类型的值表示是否插入成功或者移除成功一直阻塞：插入或者移除的操作不满足条件的时候会进行阻塞放入Condition的队列中直到满足条件后被唤醒超时退出：进行阻塞是含有时间限制的，超出时间之后线程则会退出方法，返回boolean类型的值JDK 7 提供了 7 个阻塞队列，如下。
阻塞队列-BlockingQueue
qq_36744175的博客
07-13 370
阻塞队列 public interface BlockingQueue extends Queue{…} [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3QtabpFM-1594633540746)(C:\Users\zhangzhicheng\AppData\Roaming\Typora\typora-user-images\image-20200713171249304.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vi7rTE
BlockingQueue 阻塞队列
Hello World
10-06 453
BlockingQueue 阻塞队列阻塞队列阻塞队列的用处BlockingQueue的架构图种类分析BlockingQueue核心方法代码 阻塞队列 阻塞：必须要阻塞/不得不阻塞 阻塞队列是一个队列，在数据结构中起的作用如下： 线程1往阻塞队列里添加元素，线程2从阻塞队列里移除元素 当队列是空的，从队列中获取元素的操作将会被阻塞。 当队列是满的，从队列中添加元素的操作将会被阻塞。 试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素。 试图向已满的队列中添加新元素的线程将会被阻塞，
阻塞队列 (BlockingQueue)
Aqua_yyds的博客
11-25 947
说到队列, 第一时间想到的队列的特性就是: 一种 “先进先出” 的数据结构而阻塞队列是一种特殊的队列, 也继承了队列的特性: 先进先出.但是在其先进先出的特性的基础上, 阻塞队列拥有另一种特殊的功能, 顾名思义, 就是:阻塞它在普通队列的基础上额外拥有以下几个特性:如果队列为空, 执行出队列的操作, 就会阻塞, 阻塞到另一个线程往里面添加元素为止 (队列不空)如果队列满了, 执行入队列的操作, 也会阻塞, 阻塞到另一个线程从里面取走元素为止 (队列不满)
初识阻塞队列BlockingQueue
w137960060的博客
08-14 410
一、 什么是BlockingQueue 阻塞队列，顾名思义，首先它是一个队列，而一个队列在数据结构中所起的作用大致如下图所示： 从上图我们可以很清楚看到，通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出； 常用的队列主要有以下两种： 先进先出（FIFO）：先插入的队列的元素也最先出队列，类似于排 队的功能。从某种程度上来说这种队列也体现了一种公平性。 后进先出（L
BlockingQueue阻塞队列
我的博客
09-19 438
BlockingQueue简介 阻塞队列，顾名思义，首先它是一个队列, 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出； 当队列是空的，从队列中获取元素的操作将会被阻塞 当队列是满的，从队列中添加元素的操作将会被阻塞 试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素 试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增 阻塞队列是一个队列，在数据结构中起的作用如下图： 线程1往阻塞队列里
阻塞队列BlockingQueue源码
UchihaZed的博客
02-22 217
阻塞队列BlockingQueue源码学习
阻塞队列 BlockingQueue
xingyu19911016的博客
04-17 613
默认情况下不保证线程公平地访问队列，所谓公平访问队列是指阻塞的线程，可以按照阻塞的先后顺序访问队列，即先阻塞的线程先访问队列。非公平性是对先等待的线程是非公平的，当队列可用时，阻塞的线程都可以争夺访问队列的资格，有可能先阻塞的线程最后才访问队列。阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列中取出元素的线程。注意：如果是无界阻塞队列，队列是不可能出现满的情况的，所以使用。是一个用链表实现的有界阻塞队列，此队列的默认和最大长度为。是一个不存储元素的阻塞队列。
阻塞队列（七）：BlockingQueue 总结
木村的博客
05-28 389
阻塞队列（七）：BlockingQueue 总结 经过前面六篇博客的阐述，我想各位应该对阻塞队列BlockingQueue有了较为深入的理解，下面来一个总结，先看整个类图： BlockingQueue BlockingQueue接口实现Queue接口，它支持两个附加操作：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用。相对于同一操作他提供了四种机制：抛出异常、返回特殊值、阻塞等待、超...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值