SynchronousQueueworkQueue.offer() 和 poll() 方法的超时控制及线程池的讨论

heikeb

已于 2024-11-12 11:31:45 修改

阅读量345

点赞数 5

分类专栏： java 文章标签： python 开发语言

于 2024-11-12 11:31:05 首次发布

本文链接：https://blog.youkuaiyun.com/heikeb/article/details/143707474

版权

java 专栏收录该内容

38 篇文章

订阅专栏

2024.11.12 11:26

问：workQueue.offer(command) 这里 workQueue.poll(keepAlive, TimeUnit.NANOSECONDS) : 这里的 workQueue.offer(command) 没有超时时间控制？

Claude 3.5 Haiku

非常好的问题！我来详细解释 offer() 和 poll() 方法的区别：

offer() 方法：

java

// LinkedBlockingQueue 的 offer 方法 public boolean offer(E e) { if (e == null) throw new NullPointerException(); final AtomicInteger count = this.count; if (count.get() == capacity) return false; // 队列已满直接返回 false final ReentrantLock putLock = this.putLock; putLock.lock(); try { if (count.get() < capacity) { enqueue(new Node<E>(e)); c = count.getAndIncrement(); if (c + 1 < capacity) notFull.signal(); } } finally { putLock.unlock(); } return true; }

poll() 方法：

java

// LinkedBlockingQueue 的 poll 方法（带超时） public E poll(long timeout, TimeUnit unit) throws InterruptedException { E x = null; int c = -1; final long nanos = unit.toNanos(timeout); final AtomicInteger count = this.count; final ReentrantLock takeLock = this.takeLock; takeLock.lockInterruptibly(); try { while (count.get() == 0) { if (nanos <= 0) return null; // 等待指定时间 nanos = notEmpty.awaitNanos(nanos); } x = dequeue(); c = count.getAndDecrement(); if (c > 1) notEmpty.signal(); } finally { takeLock.unlock(); } return x; }

关键区别：

offer()：

无超时机制
队列满返回 false
立即返回
不会阻塞

poll(timeout)：

有超时机制
可以等待指定时间
队列为空时会等待
超时返回 null

示例代码：

java

public class BlockingQueueDemo { public static void main(String[] args) throws InterruptedException { // 容量为2的阻塞队列 BlockingQueue<String> queue = new LinkedBlockingQueue<>(2); // offer 测试：无阻塞 System.out.println("offer 1: " + queue.offer("A")); // true System.out.println("offer 2: " + queue.offer("B")); // true System.out.println("offer 3: " + queue.offer("C")); // false，队列已满 // poll 测试：带超时 System.out.println("poll with timeout: " + queue.poll(100, TimeUnit.MILLISECONDS)); // 返回 "A" } }

线程池中的应用：

java

// 线程池中的任务提交逻辑 if (isRunning(c) && workQueue.offer(command)) { // 不会阻塞，队列满直接返回 false int recheck = ctl.get(); if (!isRunning(recheck) && remove(command)) reject(command); else if (workerCountOf(recheck) == 0) addWorker(null, false); }

如果需要超时控制的 offer，可以自定义：

java

public boolean offerWithTimeout(BlockingQueue<Runnable> queue, Runnable command, long timeout, TimeUnit unit) throws InterruptedException { return queue.offer(command, timeout, unit); }

建议：

offer() 适合快速非阻塞场景
poll(timeout) 适合需要等待的场景
线程池默认使用 offer()，快速失败
根据具体需求选择合适的队列和提交策略

问：如果是SynchronousQueue这里用offer() 方法，Synchrounous的长度为0 ，那不是直接返回false了，offer不会阻塞吗？

Claude 3.5 Haiku

对于 SynchronousQueue，offer() 方法确实不会阻塞。让我详细解释 SynchronousQueue 的特性：

SynchronousQueue 的 offer() 方法源码：

java

public boolean offer(E e) { if (e == null) throw new NullPointerException(); // 直接尝试传递，没有空闲接收者直接返回 false return transferer.transfer(e, false, 0) != null; }

关键特性：

队列长度始终为 0
offer() 不会阻塞
必须有消费者立即接收

示例代码：

java

public class SynchronousQueueDemo { public static void main(String[] args) throws InterruptedException { // 公平模式 SynchronousQueue<String> queue = new SynchronousQueue<>(true); // offer 测试 boolean offered = queue.offer("Test"); // 直接返回 false System.out.println("Offered: " + offered); // false // 正确使用方式 ExecutorService executor = Executors.newFixedThreadPool(2); // 消费者 executor.submit(() -> { try { // 等待并接收 String item = queue.take(); System.out.println("Received: " + item); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); // 生产者 executor.submit(() -> { try { // 阻塞等待传递 queue.put("Hello"); System.out.println("Put successful"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); executor.shutdown(); } }

线程池中的处理：

java

public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); // 如果线程数小于核心线程数，直接创建线程 if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } // 对于 SynchronousQueue，offer 会立即返回 false if (isRunning(c) && workQueue.offer(command)) { // 这里实际上不会执行 int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) reject(command); else if (workerCountOf(recheck) == 0) addWorker(null, false); } // 立即尝试创建新线程 else if (!addWorker(command, false)) reject(command); }

SynchronousQueue 的两种模式：

非公平模式（默认）：

java

SynchronousQueue<String> queue = new SynchronousQueue<>();

公平模式：

java

SynchronousQueue<String> queue = new SynchronousQueue<>(true);

正确使用 SynchronousQueue 的方法：

put() 方法：阻塞直到有消费者

java

queue.put("item"); // 阻塞直到被取走

offer(E e, long timeout, TimeUnit unit)：带超时的阻塞

java

boolean success = queue.offer("item", 1, TimeUnit.SECONDS);

线程池建议：

SynchronousQueue 适合：
- 任务处理非常快
- 不希望任务排队
- 希望立即创建线程
使用注意：
- 配合合适的拒绝策略
- 控制最大线程数
- 评估线程创建开销

完整示例：

java

public class ThreadPoolSynchronousQueueDemo { public static void main(String[] args) { // 使用 SynchronousQueue 的线程池 ThreadPoolExecutor executor = new ThreadPoolExecutor( 8, // 核心线程数 32, // 最大线程数 60L, // 空闲线程保留时间 TimeUnit.SECONDS, new SynchronousQueue<>(), // 无缓冲队列 new ThreadPoolExecutor.CallerRunsPolicy() // 由调用线程执行 ); // 提交大量任务 for (int i = 0; i < 50; i++) { final int taskId = i; executor.submit(() -> { System.out.println("Task " + taskId + " executed by " + Thread.currentThread().getName()); try { Thread.sleep(100); // 模拟任务执行 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } executor.shutdown(); } }

关键点总结：

推荐使用 put() 或 offer(E, timeout)
线程池会立即尝试创建新线程
选择合适的拒绝策略很重要

问：SynchronousQueue 如果有空闲线程在pool ，那是不是直接能offer

Claude 3.5 Haiku

非常好的追问！我们来深入分析 SynchronousQueue 的 offer 行为。

关键源码：

java

public boolean offer(E e) { // 调用 transfer 方法 return transferer.transfer(e, false, 0) != null; }

transfer 方法的核心逻辑：

如果有空闲线程（消费者）在等待，直接传递任务
没有空闲线程，立即返回 false

示例验证代码：

java

public class SynchronousQueueDemo { public static void main(String[] args) throws InterruptedException { // 创建线程池 ThreadPoolExecutor executor = new ThreadPoolExecutor( 8, // 核心线程数 32, // 最大线程数 60L, // 空闲线程保留时间 TimeUnit.SECONDS, new SynchronousQueue<>(), // 无缓冲队列 new ThreadPoolExecutor.CallerRunsPolicy() ); // 先创建一些线程，使线程池有空闲线程 for (int i = 0; i < 5; i++) { executor.submit(() -> { try { Thread.sleep(1000); // 模拟长任务 System.out.println("Long running task"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); } // 等待线程创建 Thread.sleep(100); // 检查是否能直接 offer SynchronousQueue<Runnable> queue = (SynchronousQueue<Runnable>) executor.getQueue(); // 模拟任务 Runnable task = () -> System.out.println("Quick task executed"); // 尝试 offer boolean offered = queue.offer(task); System.out.println("Task offered: " + offered); // 关闭线程池 executor.shutdown(); } }

深入源码分析 transfer 方法：

java

// SynchronousQueue 内部 TransferQueue 实现 E transfer(E e, boolean timed, long nanos) { QNode s = null; boolean isData = (e != null); while (true) { QNode m = head; // 如果有等待的消费者线程 if (m != null && m.isData != isData) { // 直接匹配并传递任务 Object x = m.match(e); if (x != null) { return (E) x; } } // 没有匹配的线程，返回 null return null; } }

关键点：

如果线程池有空闲线程，SynchronousQueue 的 offer 会成功
成功的前提是：
- 有空闲线程在等待任务
- 线程处于 WAITING 状态
- 线程在 workQueue 中

验证代码：

java

public class SynchronousQueueDetailDemo { public static void main(String[] args) throws Exception { // 创建线程池 ThreadPoolExecutor executor = new ThreadPoolExecutor( 8, // 核心线程数 32, // 最大线程数 60L, // 空闲线程保留时间 TimeUnit.SECONDS, new SynchronousQueue<>(), // 无缓冲队列 new ThreadPoolExecutor.CallerRunsPolicy() ); // 场景1：有空闲线程 CountDownLatch latch = new CountDownLatch(1); // 提交一个长任务，但很快返回 Future<?> longTask = executor.submit(() -> { try { latch.await(); // 模拟线程等待 System.out.println("Long task completed"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); // 等待线程创建 Thread.sleep(100); // 获取队列 SynchronousQueue<Runnable> queue = (SynchronousQueue<Runnable>) executor.getQueue(); // 尝试 offer Runnable quickTask = () -> System.out.println("Quick task executed"); boolean offered = queue.offer(quickTask); System.out.println("Task offered: " + offered); // 释放长任务 latch.countDown(); // 关闭线程池 executor.shutdown(); } }

总结：