数据结构与算法——Java实现 31.阻塞队列

于 2024-10-08 21:11:47 发布
阅读量128 收藏 3
点赞数 3
分类专栏： 数据结构与算法 —— Java实现 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73983707/article/details/142712648
版权

                        —— 24.10.8

一、问题提出

目前队列存在的问题

1.很多场景要求分离生产者、消费者两个角色、它们需要由不同的线程来担当，而之前的实现根本没有考虑线程安全问题

2.poll方法，队列为空，那么在之前的实现里会返回null，如果就是硬要拿到一个元素呢?以现在的实现只能不断循环尝试

3.offer方法，队列为满，那么在之前的实现里会返回false，如果就是硬要塞入一个元素呢?以现在的实现只能不断循环尝试

4.指令交错，多个线程会造成混乱效果

二、解决方法

 为解决线程不安全问题，需要给线程加锁，使线程局部阻塞

用条件变量让 poll 或 offer 线程进入等待 状态，而不是不断循环尝试，让CPU空转

三、单锁实现

Java中两种锁的选择

① synchronized：关键字，功能少

② ReentrantLock：可重入锁，功能丰富

lock() 加锁

unlock() 解锁

lockInterruptibly() 加锁（可在阻塞时打断，提前唤醒）

offer方法实现

if判断

问题

从 tailWaits 中唤醒的线程，会与新来的 offer 的线程争抢锁，谁能抢到是不一定的，如果后者先抢到，就会导致条件又发生变化

这种情况称之为虚假唤醒，唤醒后应该重新检查条件，看是不是得重新进入等待

    public void offer(String e) throws InterruptedException {
        // 加锁，可重入锁阻塞时可打断方法（可被强制唤醒）
        lock.lockInterruptibly();
        try {
            // 判断是否为满
            if (isFull()){
                // 队列满时，使offer线程阻塞,直到poll线程取走后，有位置时再恢复运行
                // tail.signal() 唤醒线程
                tailWaits.await();
            }
            array[tail] = e;
            if (++tail == array.length){
                tail = 0;
            }
            size++;
        }finally {
            // 解锁
            lock.unlock();
        }
    }
import java.util.Arrays;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class TestThreadUnsafe {
    private final String[] array = new String[10];
    // 尾指针
    private int tail = 0;
    // 元素个数
    private int size = 0;
    // 创建一个可重入锁对象
    ReentrantLock lock = new ReentrantLock();
    // 条件变量对象（集合线程）
    Condition tailWaits = lock.newCondition();

    public void offer(String e) throws InterruptedException {
        // 加锁，可重入锁阻塞时可打断方法（可被强制唤醒）
        lock.lockInterruptibly();
        try {
            // 判断是否为满
            if (isFull()){
                // 队列满时，使offer线程阻塞,直到poll线程取走后，有位置时再恢复运行
                // tail.signal() 唤醒线程
                tailWaits.await();
            }
            array[tail] = e;
            if (++tail == array.length){
                tail = 0;
            }
            size++;
        }finally {
            // 解锁
            lock.unlock();
        }
    }

    public void poll(String e) throws InterruptedException {

    }

    @Override
    public String toString() {
        return Arrays.toString(array);
    }

    private boolean isFull(){
        return size == array.length;
    }

    private boolean isEmpty(){
        return size == 0;
    }

    public static void main(String[] args) throws InterruptedException{
        TestThreadUnsafe queue = new TestThreadUnsafe();
        for (int i = 0; i < 10; i++) {
            queue.offer("e"+i);
        }
        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"添加元素之前");
                queue.offer("e10");
                System.out.println(Thread.currentThread().getName()+"添加元素成功");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },"t1").start();

        new Thread(()->{
            System.out.println("开始唤醒");
            try{
                queue.lock.lockInterruptibly();
                queue.tailWaits.signal();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }finally {
                queue.lock.unlock();
            }
        },"t2").start();
    }
}

while判断 

解决了虚假唤醒的问题

    @Override
    public void offer(E e) throws InterruptedException {    // poll 等待队列非空
        lock.lockInterruptibly();
        try{
            while (isFull()){
                // 放在条件变量等待
                tailWaits.await();
            }
            array[tail] = e;
            if (++tail == array.length){
                tail = 0;
            }
            size++;
            // 唤醒等待线程
            headWaits.signal();
        }finally {
            lock.unlock();
        }
    }
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class BlockingQueue1<E> implements BlockingQueue<E> {
    private final E[] array;
    private int head;
    private int tail;
    private int size;

    // 根据容量创造一个数组
    public BlockingQueue1(int capacity) {
        array = (E[]) new Object[capacity];
    }

    // 加可重入锁
    private ReentrantLock lock = new ReentrantLock();
    // 配合poll方法条件变量，在队列头部删除
    private Condition headWaits = lock.newCondition();
    // 配合offer方法条件变量，在队列尾部加入
    private Condition tailWaits = lock.newCondition();

    // 判空
    private boolean isEmpty(){
        return head == tail;
    }

    // 判满
    private boolean isFull(){
        return size == array.length;
    }

    @Override
    public String toString() {
        return "array=" + Arrays.toString(array);
    }

    @Override
    public void offer(E e) throws InterruptedException {    // poll 等待队列非空
        lock.lockInterruptibly();
        try{
            while (isFull()){
                // 放在条件变量等待
                tailWaits.await();
            }
            array[tail] = e;
            if (++tail == array.length){
                tail = 0;
            }
            size++;
            // 唤醒等待线程
            headWaits.signal();
        }finally {
            lock.unlock();
        }
    }

    @Override
    public boolean offer(E e, long timeout) throws InterruptedException {
        lock.lockInterruptibly();
        try{
            // 将毫秒时间转换为纳秒时间
            long t = TimeUnit.MILLISECONDS.toNanos(timeout);
            while (isFull()){
                if (t<=0){
                    return false;
                }
                // 最多等待多少纳秒
                tailWaits.awaitNanos(t);
            }
            array[tail] = e;
            if (++tail == array.length){
                tail = 0;
            }
            size++;
            // 唤醒等待线程
            headWaits.signal();
            return true;
        }finally {
            lock.unlock();
        }
    }

    @Override
    public E poll() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (isEmpty()){
                headWaits.await();
            }
            E e = array[head];
            array[head] = null;
            if (++head == array.length){
                head = 0;
            }
            size--;
            tailWaits.signal();
            return e;
        }finally {
            lock.unlock();
        }
    }
}

 main函数

public class TestBlockingQueue1 {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue1<String> queue = new BlockingQueue1<>(3);

        Thread t1 = new Thread(() -> {
            try {
                System.out.println(System.currentTimeMillis()+" begin ");
                queue.offer("任务1");
                System.out.println(queue);
                queue.offer("任务2");
                System.out.println(queue);
                queue.offer("任务3");
                System.out.println(queue);
                queue.offer("任务4",5000);
                System.out.println(queue);
                System.out.println(System.currentTimeMillis() + " end ");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },"生产者");
        t1.start();

        Thread.sleep(2000);
        queue.poll();
    }
}

 

四、双锁实现

单锁问题：

单锁实现的缺陷：两个线程用了同一把锁，一个执行时，另一个就需阻塞，而offer方法添加元素和poll方法取走元素使用了同一把锁，这样两个线程不能同时执行，两方法相互阻塞

解决方法：

offer方法主要操作尾指针，poll方法主要操作头指针，将offer方法和poll方法分别添加一个锁，用两把锁分别保护头指针和尾指针，从而分别保护offer和poll两个方法

代码实现

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

public class BlockingQueue2<E> implements BlockingQueue<E> {
    private final E[] array;
    private int head;
    private int tail;
    private int size;

    // tailLock给offer方法入队用,Condition分别创建两个等待的条件变量
    private ReentrantLock tailLock = new ReentrantLock();
    private Condition notEmpty = tailLock.newCondition();
    // headLock给poll方法出队用
    private ReentrantLock headLock = new ReentrantLock();
    private Condition notFull = headLock.newCondition();

    public BlockingQueue2(int capacity) {
        this.array = (E[]) new Object[capacity];
    }

    // 判空
    private boolean isEmpty(){
        return size == 0;
    }

    // 判满
    private boolean isFull(){
        return size == array.length;
    }

    @Override
    public String toString() {
        return "array=" + Arrays.toString(array);
    }

    @Override
    public void offer(E e) throws InterruptedException {
        // 加锁
        tailLock.lockInterruptibly();
        try{
            while (isFull()) {
                notEmpty.await();
            }
            array[tail] = e;
            if (++tail == array.length) {
                tail = 0;
            }
            size++;
        }finally {
            tailLock.unlock();
        }
    }

    @Override
    public boolean offer(E e, long timeout) throws InterruptedException {
        return false;
    }

    @Override
    public E poll() throws InterruptedException {
        // 加锁
        headLock.lockInterruptibly();
        try{
            while (isEmpty()){
                notEmpty.await();
            }
            E e = array[head];
            array[head] = null;
            if (++head == array.length) {
                head = 0;
            }
            size--;
            return e;
        }finally {
            headLock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue2<String> queue = new BlockingQueue2<>(3);
        queue.offer("任务1");

        new Thread(()->{
            try {
                queue.offer("任务2");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },"offer").start();

        new Thread(()->{
            try {
                System.out.println(queue.poll());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        },"poll").start();
    }
}

size自增/自减问题

size的自增自减不能保障安全，size自增自减在多个线程同时执行时可能遇到冲突

解决方法

用原子变量AtomicInteger类型保证安全

getAndIncrement 自增方法，能保证线程安全

getAndDecrement 自减方法，能保证线程安全

L_cl
关注
专栏目录
大数据——数据结构.pdf
07-11
【大数据——数据结构】 在计算机科学中，数据结构是组织和管理大量数据的方式，而堆与栈是两种关键的数据结构，特别是在处理大数据时显得尤为重要。它们在内存中的工作方式直接影响到程序的性能和效率。 一、堆与...
数据结构——队列的实现
10-26
3. 高级数据结构实现：如Java的`java.util.Queue`接口，提供了多种队列实现，如`ArrayDeque`（基于数组的双端队列）、`LinkedList`（链表实现）等。 队列的应用场景： 1. 打印机任务调度：新任务入队，完成的任务出...
poj与leetcode-AlgorithmComplete:数据结构、算法及常见面试题：java实现
06-30
《poj与LeetCode——数据结构、算法及常见面试题：Java实现》是针对程序员提升算法能力和解决实际问题的一份宝贵资源。这个项目主要涵盖了在编程竞赛如POJ（Programming Online Judge）和在线编程平台LeetCode上的...
Java八股简历模板——3年.docx
07-18
- **分布式锁**：理解分布式锁的必要性与实现原理，如基于Redis或Zookeeper的分布式锁方案。 - **分布式事务**：掌握X/Open XA协议、两阶段提交（2PC）、三阶段提交（3PC）等分布式事务处理方案。 - **分布式session...
java面试——深圳-商汤科技-Java高级.zip
09-26
11. **数据结构与算法**：虽然Java面试不一定直接考察算法，但良好的数据结构基础和解决问题的能力是必不可少的。了解常见数据结构如数组、链表、栈、队列、树、图等，以及排序、查找等基础算法。 以上知识点只是...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 882
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 286
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 489
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1000
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 628
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Springboot人才求职招聘系统源码（前台+后台）
最新发布
10-06 460
项目技术：springboot运行环境：jdk1.8+idea/eclipse+maven3+mysql5.6。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1471
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 824
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java中的break、continue和return语句
weixin_73230994的博客
10-05 352
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 933
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
11.2 Linux_线程_同步与互斥
Fresh_man111的博客
10-03 183
同一时刻只允许一个任务访问的共享资源。比如写入文件，就是一个临界资源，当写入文件时，不允许两个任务同时往里面写。如果A写入abc，B写入def，同时写的情况下文件中的值不一定为abcdef，这时就需要在某一时刻只允许A写入abc，在另一时刻只允许B写入def。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 402
记忆中，两个指针合并即可。
SpringBoot线程问题
juanmiao的专栏
10-04 493
程序，线程，线程池进程是资源分配最小单位，线程是程序执行的最小单位。计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配，每个进程都有相应的线程，在执行程序是，实际上是执行相应的一系列线程。线程：程序执行流的最小执行单位，是行程中实际运作单位，经常容易和进程这个概念混淆简单来说，一个应用程序的运行就可以被看做是一个进程。是运行中实际的执行任务者，可以说，进程中包含了多个可以同时运行的线程。线程的生命周期。
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1060
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值