阻塞队列 BlockingQueue

发布时间：2026/8/2 1:20:30

阻塞队列 BlockingQueue

文章目录

  • BlockingQueue 阻塞队列
  • 一、BlockingQueue 接口
    • 1、概述
    • 2、接口方法
    • 3、小结
  • 二、ArrayBlockingQueue
    • 1、概述
    • 2、基本实现
    • 3、put 方法详解
    • 4、take 方法详解
    • 5、使用示例
  • 三、LinkedBlockingQueue
    • 1、概述
    • 2、基本实现
    • 3、put 方法详解
    • 4、take 方法详解
    • 5、对比 ArrayBlockingQueue
    • 6、使用示例
  • 四、PriorityBlockingQueue
  • 五、SynchronousQueue
  • 六、DelayQueue
  • 七、LinkedBlockingDeque
  • 八、LinkedTransferQueue

BlockingQueue 阻塞队列

一、BlockingQueue 接口

1、概述

BlockingQueue 代表了一个线程安全的阻塞队列，不仅可以由多个线程并发访问，还提供了可阻塞的插入和移除方法。

  • 当队列已满，向队列中 put 添加元素时（生产）会被阻塞，直到队列有足够的空间。
  • 当队列为空，从队列中 take 移除元素时（消费）会被阻塞，直到队列有元素可用。

因此，BlockingQueue 被广泛用于“生产者-消费者”问题中。

2、接口方法

BlockingQueue 接口继承于 Queue 接口

public interface Queue<E> extends Collection<E> {// 将指定的元素插入到队列中，如果队列已满，则抛出 IllegalStateException 异常。boolean add(E e);// 将指定的元素插入到队列中，如果队列已满，则返回 false，否则返回 true。boolean offer(E e);// 移除并返回队列的头部元素，如果队列为空，则抛出 NoSuchElementException 异常。E remove();// 移除并返回队列的头部元素，如果队列为空，则返回 null。E poll();// 获取但不移除队列的头部元素，如果队列为空，则抛出 NoSuchElementException 异常。E element();// 获取但不移除队列的头部元素，如果队列为空，则返回 null。E peek();
}

BlockingQueue 接口还扩展了以下方法（可以看到有阻塞的插入和移除方法）

public interface BlockingQueue<E> extends Queue<E> {// 将指定的元素插入到队列中，如果队列已满，则阻塞等待，直到队列有足够的空间。void put(E e) throws InterruptedException;// 移除并返回队列的头部元素，如果队列为空，则阻塞等待，直到队列有元素可用。E take() throws InterruptedException;// 带超时时间的offerboolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;// 带超时时间的pollE poll(long timeout, TimeUnit unit) throws InterruptedException;// 从阻塞队列中移除并返回指定数量的元素，并将它们添加到给定的集合中。int drainTo(Collection<? super E> c);// maxElements：要移除的最大元素数量。int drainTo(Collection<? super E> c, int maxElements);// 返回当前阻塞队列中剩余的可用容量，即队列中可以插入的元素数量。int remainingCapacity();
}

3、小结

总结一下 BlockingQueue 主要的几个方法：

方式抛出异常不抛异常，返回false或null阻塞等待超时等待
添加add(E e)offer(E e)put(E e)offer(e, timeout, unit)
移除并返回首个remove()poll()take()poll(timeout, unit)
获取不移除首个element()peek()——

二、ArrayBlockingQueue

1、概述

ArrayBlockingQueue 是一个基于数组的有界阻塞队列：

  • 有界：在构造时就确定了容量大小，并且在之后不能更改。这个界限提供了流量控制，有助于资源的合理使用。
  • FIFO：队列操作符合先进先出的原则。
  • 公平：构造方法提供的boolean fair参数，可以指定是否公平。

2、基本实现

// java.util.concurrent.ArrayBlockingQueue/** The queued items */
final Object[] items;/** items index for next take, poll, peek or remove */
int takeIndex;/** items index for next put, offer, or add */
int putIndex;/** Number of elements in the queue */
int count;/** Concurrency control uses the classic two-condition algorithm* found in any textbook.*//** Main lock guarding all access */
final ReentrantLock lock;/** Condition for waiting takes */
private final Condition notEmpty;/** Condition for waiting puts */
private final Condition notFull;public ArrayBlockingQueue(int capacity, boolean fair) {if (capacity <= 0) throw new IllegalArgumentException();this.items = new Object[capacity];lock = new ReentrantLock(fair);notEmpty = lock.newCondition();notFull =  lock.newCondition();
}

3、put 方法详解

// java.util.concurrent.ArrayBlockingQueuepublic void put(E e) throws InterruptedException {checkNotNull(e);final ReentrantLock lock = this.lock;lock.lockInterruptibly();try {// 如果当前队列已满，将线程移入到notFull等待队列中while (count == items.length)notFull.await();// 满足插入数据的要求，直接进行入队操作enqueue(e);} finally {lock.unlock();}
}private void enqueue(E x) {// assert lock.getHoldCount() == 1;// assert items[putIndex] == null;final Object[] items = this.items;// 插入数据items[putIndex] = x;if (++putIndex == items.length)putIndex = 0;count++;// 唤醒阻塞的消费者线程，当前队列中有数据可供消费notEmpty.signal();
}

4、take 方法详解

// java.util.concurrent.ArrayBlockingQueuepublic E take() throws InterruptedException {final ReentrantLock lock = this.lock;lock.lockInterruptibly();try {// 如果当前队列为空，将线程移入到notEmpty等待队列中while (count == 0)notEmpty.await();// 获取数据return dequeue();} finally {lock.unlock();}
}private E dequeue() {final Object[] items = this.items;@SuppressWarnings("unchecked")// 获取数据E x = (E) items[takeIndex];items[takeIndex] = null;if (++takeIndex == items.length)takeIndex = 0;count--;if (itrs != null)itrs.elementDequeued();// 唤醒阻塞的生产者线程，队列已经空出来了。notFull.signal();return x;
}

5、使用示例

public class ArrayBlockingQueueDemo {public static void main(String[] args) {BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);// Producernew Thread(() -> {try {for (int i = 0; i < 10; i++) {queue.put(i);System.out.println("Produced: " + i);Thread.sleep(1000);}} catch (InterruptedException e) {// Todo Handle Exception}}).start();// Consumernew Thread(() -> {try {for (int i = 0; i < 10; i++) {int value = queue.take();System.out.println("Consumed: " + value);Thread.sleep(2000);}} catch (InterruptedException e) {// Todo Handle Exception}}).start();}
}

三、LinkedBlockingQueue

1、概述

LinkedBlockingQueue 是一个基于链表的有界/无界阻塞队列：

  • 可以在队列头部和尾部进行高效的插入和删除操作。
  • 可以在构造时指定最大容量。如果不指定，默认为 Integer.MAX_VALUE，这意味着队列的大小受限于可用内存。

2、基本实现

// java.util.concurrent.LinkedBlockingQueue/** Current number of elements */
private final AtomicInteger count = new AtomicInteger();/*** Head of linked list.* Invariant: head.item == null*/
transient Node<E> head;/*** Tail of linked list.* Invariant: last.next == null*/
private transient Node<E> last;/** Lock held by take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();/** Wait queue for waiting takes */
private final Condition notEmpty = takeLock.newCondition();/** Lock held by put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();/** Wait queue for waiting puts */
private final Condition notFull = putLock.newCondition();static class Node<E> {// 头节点的 item 始终为 null，它作为一个虚拟节点，用于帮助管理队列。E item;// 尾节点的 next 始终为 null，因为没有下一个元素了Node<E> next;Node(E x) { item = x; }
}

3、put 方法详解

// java.util.concurrent.LinkedBlockingQueuepublic void put(E e) throws InterruptedException {if (e == null) throw new NullPointerException();// 用于存储操作前的队列元素数量，预设为 -1 表示失败，除非稍后设置。int c = -1;// 创建一个新的节点包含要插入的元素 e。Node<E> node = new Node<E>(e);// 获取put锁和计数器。final ReentrantLock putLock = this.putLock;final AtomicInteger count = this.count;putLock.lockInterruptibly();try {// 如果队列已满，则阻塞当前线程，将其移入等待队列while (count.get() == capacity) {notFull.await();}// 入队操作，插入数据enqueue(node);c = count.getAndIncrement();// 队列没有满，则通知被阻塞的生产者线程if (c + 1 < capacity)notFull.signal();} finally {putLock.unlock();}// 如果插入操作将队列从空变为非空，唤醒可能正在等待非空队列的消费者线程。if (c == 0)signalNotEmpty();
}private void enqueue(Node<E> node) {// assert putLock.isHeldByCurrentThread();// assert last.next == null;last = last.next = node;
}private void signalNotEmpty() {final ReentrantLock takeLock = this.takeLock;takeLock.lock();try {notEmpty.signal();} finally {takeLock.unlock();}
}

4、take 方法详解

// java.util.concurrent.LinkedBlockingQueuepublic E take() throws InterruptedException {// 用于存储被取出的元素。E x;// 用于存储操作前的队列元素数量，预设为 -1 表示失败，除非稍后设置。int c = -1;// 获取计数器和take锁final AtomicInteger count = this.count;final ReentrantLock takeLock = this.takeLock;takeLock.lockInterruptibly();try {// 当前队列为空，则阻塞当前线程，将其移入到等待队列中，直至满足条件while (count.get() == 0) {notEmpty.await();}// 移除队头元素，获取数据x = dequeue();c = count.getAndDecrement();// 如果当前满足移除元素的条件，则通知被阻塞的消费者线程if (c > 1)notEmpty.signal();} finally {takeLock.unlock();}if (c == capacity)signalNotFull();return x;
}private E dequeue() {Node<E> h = head;Node<E> first = h.next;h.next = h; // help GChead = first;E x = first.item;first.item = null;return x;
}private void signalNotFull() {final ReentrantLock putLock = this.putLock;putLock.lock();try {notFull.signal();} finally {putLock.unlock();}
}

5、对比 ArrayBlockingQueue

相同点：

ArrayBlockingQueue 和 LinkedBlockingQueue 都是通过 Condition 通知机制来实现可阻塞的插入和删除。

不同点：

  1. ArrayBlockingQueue 基于数组实现，而 LinkedBlockingQueue 基于链表实现；
  2. ArrayBlockingQueue 使用一个单独的 ReentrantLock 来控制对队列的访问，而 LinkedBlockingQueue 使用两个锁（putLock 和 takeLock），一个用于放入操作，另一个用于取出操作。这可以提供更细粒度的控制，并可能减少线程之间的竞争。

6、使用示例

public class LinkedBlockingQueueDemo {public static void main(String[] args) {BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);// Producernew Thread(() -> {try {for (int i = 0; i < 10; i++) {queue.put(i);System.out.println("Produced: " + i);Thread.sleep(1000);}} catch (InterruptedException e) {// Todo Handle Exception}}).start();// Consumernew Thread(() -> {try {for (int i = 0; i < 10; i++) {int value = queue.take();System.out.println("Consumed: " + value);Thread.sleep(2000);}} catch (InterruptedException e) {// Todo Handle Exception}}).start();}
}

四、PriorityBlockingQueue

PriorityBlockingQueue 是一个具有优先级排序特性的无界阻塞队列。

  • 可以在构造方法中指定 Comparator 比较器进行定制排序。
  • 如果没有指定，遵循自然排序（如果队列存储的元素已经实现了Comparable，会使用实现的）

当需要根据优先级来执行任务时，PriorityBlockingQueue 会非常有用。

【构造函数】

// java.util.concurrent.PriorityBlockingQueuepublic PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator) {if (initialCapacity < 1) throw new IllegalArgumentException();this.lock = new ReentrantLock();this.notEmpty = lock.newCondition();this.comparator = comparator;this.queue = new Object[initialCapacity];
}

【使用示例】

class Task implements Comparable<Task> {private int priority;private String name;public Task(int priority, String name) {this.priority = priority;this.name = name;}public int compareTo(Task other) {return Integer.compare(other.priority, this.priority); // higher values have higher priority}public String getName() {return name;}
}public class PriorityBlockingQueueDemo {public static void main(String[] args) throws InterruptedException {PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();queue.put(new Task(1, "Low priority task"));TimeUnit.MILLISECONDS.sleep(100);queue.put(new Task(10, "Medium priority task"));TimeUnit.MILLISECONDS.sleep(100);queue.put(new Task(50, "High priority task"));while (!queue.isEmpty()) {System.out.println(queue.take().getName());}}
}

五、SynchronousQueue

SynchronousQueue 是一个非常特殊的阻塞队列，它不存储任何元素。

  • 每一个插入操作必须等待另一个线程的移除操作，反之亦然。

因此，SynchronousQueue 的内部实际上是空的，但它允许一个线程向另一个线程逐个传输元素。

【使用示例】

public class SynchronousQueueDemo {public static void main(String[] args) {SynchronousQueue<String> queue = new SynchronousQueue<>();new Thread(() -> {try {System.out.println(Thread.currentThread().getName() + " put a");queue.put("a");System.out.println(Thread.currentThread().getName() + " put b");queue.put("b");} catch (InterruptedException e) {e.printStackTrace();}}, "A").start();new Thread(() -> {try {TimeUnit.SECONDS.sleep(2);String a = queue.take();System.out.println(Thread.currentThread().getName() + " take " + a);TimeUnit.SECONDS.sleep(2);String b = queue.take();System.out.println(Thread.currentThread().getName() + " take " + b);} catch (InterruptedException e) {// Todo Handle Exception}}, "B").start();}
}

put 了一个元素，必须先 take 取出来，否则不能再 put 进去值（存一个取一个，最多一个）

六、DelayQueue

DelayQueue 是一个无界阻塞队列，用于存放实现了 Delayed 接口的元素，这些元素只能在其到期时才能从队列中取走。这使得 DelayQueue 成为实现时间基于优先级的调度服务的理想选择。

【使用示例】

public class DelayQueueDemo {public static void main(String[] args) {DelayQueue<DelayedElement> queue = new DelayQueue<>();// 将带有5秒延迟的元素放入队列queue.put(new DelayedElement(5000, "这是一个 5 秒延迟的元素"));try {System.out.println("取一个元素...");// take() 将阻塞，直到延迟到期DelayedElement element = queue.take();System.out.println(element.getMessage());} catch (InterruptedException e) {// Todo Handle Exception}}/*** DelayQueueDemo存储的元素，需要实现Delayed接口*/static class DelayedElement implements Delayed {private final long delayUntil;private final String message;public DelayedElement(long delayInMillis, String message) {this.delayUntil = System.currentTimeMillis() + delayInMillis;this.message = message;}public String getMessage() {return message;}@Overridepublic long getDelay(TimeUnit unit) {return unit.convert(delayUntil - System.currentTimeMillis(), TimeUnit.MILLISECONDS);}@Overridepublic int compareTo(Delayed o) {return Long.compare(this.delayUntil, ((DelayedElement) o).delayUntil);}}
}

七、LinkedBlockingDeque

LinkedBlockingDeque 是一个基于链表结构的双端阻塞队列。它同时支持从队列头部插入和移除元素，也支持从队列尾部插入和移除元素。因此，LinkedBlockingDeque 可以作为 FIFO 队列或 LIFO 队列来使用。

常用方法有：

  • addFirst(E e), addLast(E e)：在队列的开头/结尾添加元素。

  • takeFirst(), takeLast()：从队列的开头/结尾移除和返回元素，如果队列为空，则等待。

  • putFirst(E e), putLast(E e)：在队列的开头/结尾插入元素，如果队列已满，则等待。

  • pollFirst(long timeout, TimeUnit unit), pollLast(long timeout, TimeUnit unit)：

    在队列的开头/结尾移除和返回元素，如果队列为空，则等待指定的超时时间。

【使用示例】

public class LinkedBlockingDequeDemo {public static void main(String[] args) throws InterruptedException {LinkedBlockingDeque<String> deque = new LinkedBlockingDeque<>(10);// Adding elements at the end of the dequedeque.putLast("Item1");deque.putLast("Item2");// Adding elements at the beginning of the dequedeque.putFirst("Item3");// Removing elements from the beginningSystem.out.println(deque.takeFirst()); // Output: Item3// Removing elements from the endSystem.out.println(deque.takeLast()); // Output: Item2}
}

运行结果如下：

Item3
Item2

八、LinkedTransferQueue

LinkedTransferQueue 是一个基于链表结构的无界传输队列，

LinkedTransferQueue 实现了 TransferQueue 接口，提供了一种强大的线程间交流机制

  • 允许一个元素直接从生产者传输给消费者，如果消费者已经在等待。如果没有等待的消费者，元素将入队。
public interface TransferQueue<E> extends BlockingQueue<E> {// 尝试立即转移元素，如果有消费者正在等待，则传输成功；否则，返回 false。boolean tryTransfer(E e);// 将元素转移到等待的消费者，如果不存在等待的消费者，则元素会入队并阻塞直到该元素被消费。void transfer(E e) throws InterruptedException;boolean tryTransfer(E e, long timeout, TimeUnit unit) throws InterruptedException;
}

如果想要更紧密地控制生产者和消费者之间的交互，可以使用 LinkedTransferQueue。

【使用示例】

public class LinkedTransferQueueDemo {public static void main(String[] args) {LinkedTransferQueue<Integer> queue = new LinkedTransferQueue<>();// Producernew Thread(() -> {try {for (int i = 0; i < 10; i++) {queue.transfer(i); // 将元素传输给消费者线程System.out.println("Produced: " + i);}} catch (InterruptedException e) {// Todo Handle Exception}}).start();// Consumernew Thread(() -> {try {for (int i = 0; i < 10; i++) {TimeUnit.SECONDS.sleep(1);int value = queue.take();System.out.println("Consumed: " + value);}} catch (InterruptedException e) {// Todo Handle Exception}}).start();}
}

相关新闻

webpack5 常用插件使用

webpack5 常用插件使用

webpack5常用插件使用 1. CleanWebpackPlugin2. HtmlWebpackPlugin3. DefinePlugin4.CopyWebpackPlugin 1. CleanWebpackPlugin 问题&#xff1a;每次打包完都需要手动删除掉dist文件目录&#xff0c;使用CleanWebpackPlugin就可自动清除dist目录。作用&#xff1a;自动清除di…

2026/8/2 1:44:57
C语言——oj刷题——杨氏矩阵

C语言——oj刷题——杨氏矩阵

目录 1. 理解杨氏矩形的特点 2. 实现杨氏矩形查找算法 3. 编写示例代码 当我们谈到杨氏矩形时&#xff0c;我们指的是一种在二维数组中查找目标元素的高效算法。它是由杨氏&#xff08;Yan Shi&#xff09;教授提出的&#xff0c;因此得名为杨氏矩形。 杨氏矩形问题的场景是…

2026/8/2 1:31:35
linux 09 软件安装,YUM

linux 09 软件安装,YUM

下载软件时候&#xff0c;windows会从网上下载exe文件。 windows中的exe文件linux中的rpm文件 简介部分&#xff1a; 其中的认识RPM包&#xff1a; 管理RPM包&#xff1a; 其中的YUM&#xff1a; YUM&#xff08;软件包管理工具&#xff09; 01.YUM工具简介 02.使用YUM 第…

2026/7/31 17:05:19

最新新闻

2026年8月西安市电信500M融合宽带怎么选_办理时要注意哪些关键细节_ - 找卡家园

2026年8月西安市电信500M融合宽带怎么选_办理时要注意哪些关键细节_ - 找卡家园

2026年7月西安市电信500M融合宽带怎么选?办理时要注意哪些关键细节?先说说我自己的经历吧。以前租房子那会儿，图便宜办了个小运营商的宽带，一到晚上追剧就卡成PPT，打游戏直接掉线，跟客服掰扯了半个月才给处理。后…

2026/8/2 2:39:58
STM32仿生蝴蝶DIY：从PWM控制到舵机驱动的嵌入式入门实践

STM32仿生蝴蝶DIY：从PWM控制到舵机驱动的嵌入式入门实践

这次我们来看一个基于 STM32 的仿生蝴蝶项目。它不是一个复杂的商业产品&#xff0c;而是一个非常适合电子爱好者、嵌入式初学者和创客在家庭环境下动手制作的 DIY 项目。核心思路是利用 STM32 微控制器作为“大脑”&#xff0c;驱动舵机或微型电机来模拟蝴蝶翅膀的扑动&#x…

2026/8/2 2:39:55
动力学可逆性与因果涌现：从微观噪声到宏观规律的数学探索

动力学可逆性与因果涌现：从微观噪声到宏观规律的数学探索

1. 项目概述&#xff1a;从“涌现”到“因果”的深度探索最近在跟进一个挺有意思的交叉领域读书会&#xff0c;主题是“因果涌现”。第二期的核心&#xff0c;聚焦在了一个听起来有点抽象&#xff0c;但细想之下又非常深刻的概念上&#xff1a;基于动力学可逆性的因果涌现。这可…

2026/8/2 2:39:54
Remio：为AI编程助手构建持续工作记忆，告别重复对话

Remio：为AI编程助手构建持续工作记忆，告别重复对话

如果你用过 Claude、ChatGPT 或任何 AI 编程助手&#xff0c;一定遇到过这个场景&#xff1a;你花半小时向它解释你的项目背景、代码结构、业务逻辑&#xff0c;它终于能给出靠谱的建议。但当你关掉对话窗口&#xff0c;或者第二天打开一个新对话&#xff0c;一切又回到了原点—…

2026/8/2 2:39:54
基于ESP32与QQ机器人框架DIY智能硬件助手：从环境搭建到功能扩展

基于ESP32与QQ机器人框架DIY智能硬件助手：从环境搭建到功能扩展

想不想用一块小小的开发板&#xff0c;打造一个能陪你聊天、查天气、控制家电的QQ智能机器人&#xff1f;这听起来像是极客的专属玩具&#xff0c;但实现起来远比想象中简单。基于ESP32这款强大的物联网芯片&#xff0c;结合开源的QQ机器人框架&#xff0c;我们完全可以DIY一个…

2026/8/2 2:39:54
43元大艺电池改造：低成本获取21700电芯与DIY移动电源全指南

43元大艺电池改造：低成本获取21700电芯与DIY移动电源全指南

这次我们来看一个关于大艺电池的DIY改造项目。核心不是讨论电池本身&#xff0c;而是如何将一款价格低廉的43元、内含15颗21700电芯的大艺电池包&#xff0c;改造成一个通用的、高容量的移动电源解决方案。这个思路对于有动手能力的电子爱好者、户外设备供电需求者&#xff0c;…

2026/8/2 2:39:54

日新闻

最大流算法详解：从水管网络到Ford-Fulkerson与Dinic实战

最大流算法详解：从水管网络到Ford-Fulkerson与Dinic实战

1. 从水管网络到最大流&#xff1a;一个核心问题的诞生想象一下&#xff0c;你是一个城市供水系统的总工程师。你的城市有多个水源&#xff08;水库&#xff09;&#xff0c;需要通过一个复杂的地下管道网络&#xff0c;将水输送到各个居民区。每条管道都有其最大通水能力&…

2026/8/2 0:00:32
基于Springboot的企业门户网站(源码+LW+调试文档+讲解)

基于Springboot的企业门户网站(源码+LW+调试文档+讲解)

温馨提示&#xff1a;本人主页置顶文章(点我)开头有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;本人主页置顶文章(点我)开头有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;本人主页置顶文章(点我)开头有 CSDN 平台…

2026/8/2 0:00:32
MATLAB xcorr函数详解：从互相关原理到四大实战应用

MATLAB xcorr函数详解：从互相关原理到四大实战应用

1. 从一次信号“找茬”说起&#xff1a;为什么我们需要互相关几年前&#xff0c;我在处理一组声学传感器数据时遇到了一个棘手的问题。我有两个麦克风记录了一段相同的音频信号&#xff0c;理论上它们接收到的声音波形应该非常相似&#xff0c;只是由于麦克风位置不同&#xff…

2026/8/2 0:00:32

周新闻

最大流算法详解：从水管网络到Ford-Fulkerson与Dinic实战

最大流算法详解：从水管网络到Ford-Fulkerson与Dinic实战

1. 从水管网络到最大流&#xff1a;一个核心问题的诞生想象一下&#xff0c;你是一个城市供水系统的总工程师。你的城市有多个水源&#xff08;水库&#xff09;&#xff0c;需要通过一个复杂的地下管道网络&#xff0c;将水输送到各个居民区。每条管道都有其最大通水能力&…

2026/8/2 0:00:32
基于Springboot的企业门户网站(源码+LW+调试文档+讲解)

基于Springboot的企业门户网站(源码+LW+调试文档+讲解)

温馨提示&#xff1a;本人主页置顶文章(点我)开头有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;本人主页置顶文章(点我)开头有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;本人主页置顶文章(点我)开头有 CSDN 平台…

2026/8/2 0:00:32
MATLAB xcorr函数详解：从互相关原理到四大实战应用

MATLAB xcorr函数详解：从互相关原理到四大实战应用

1. 从一次信号“找茬”说起&#xff1a;为什么我们需要互相关几年前&#xff0c;我在处理一组声学传感器数据时遇到了一个棘手的问题。我有两个麦克风记录了一段相同的音频信号&#xff0c;理论上它们接收到的声音波形应该非常相似&#xff0c;只是由于麦克风位置不同&#xff…

2026/8/2 0:00:32

月新闻

无损视频剪辑终极指南：如何实现快速高效的多媒体处理

无损视频剪辑终极指南：如何实现快速高效的多媒体处理

无损视频剪辑终极指南&#xff1a;如何实现快速高效的多媒体处理 【免费下载链接】lossless-cut The swiss army knife of lossless video/audio editing 项目地址: https://gitcode.com/gh_mirrors/lo/lossless-cut 在数字媒体创作领域&#xff0c;视频编辑处理的质量损…

2026/8/2 0:56:46
AI辅助本科论文写作：8大工具评测与高效使用指南

AI辅助本科论文写作：8大工具评测与高效使用指南

1. 本科生论文写作的AI辅助现状本科毕业论文是每个大学生必须跨越的一道坎。记得我当年写论文时&#xff0c;光是文献检索就花了整整两周时间&#xff0c;打印的参考文献堆满了半个书桌。如今AI技术的发展为学术写作带来了革命性变化&#xff0c;合理使用这些工具可以节省80%以…

2026/8/1 0:00:08
如何快速配置大麦自动抢票系统：从零开始搭建Python抢票助手

如何快速配置大麦自动抢票系统：从零开始搭建Python抢票助手

如何快速配置大麦自动抢票系统&#xff1a;从零开始搭建Python抢票助手 【免费下载链接】ticket-purchase 大麦自动抢票&#xff0c;支持人员、城市、日期场次、价格选择 项目地址: https://gitcode.com/GitHub_Trending/ti/ticket-purchase 还在为抢不到热门演唱会门票…

2026/8/1 0:00:08