如何优化多线程下等待列表指定索引就绪的阻塞实现？

针对你描述的场景——需要阻塞等待指定索引（或间隙后首个就绪索引）的事件，同时支持批量唤醒等待线程、避免冗余锁和资源浪费——推荐用CompletableFuture结合ConcurrentHashMap的方案，逻辑更简洁且性能更优。

核心思路 #

用ConcurrentHashMap<Long, CompletableFuture<T>>存储每个索引对应的"未来事件"：

• 当线程调用nextEvent(fromIndex)时，要么找到已存在的事件future直接等待完成，要么创建一个新的future放入map后等待；所有等待同一索引的线程会共享同一个future，事件就绪时全部被唤醒。
• 当append(T event)成功时，找到对应索引的future并完成它；如果没有线程在等待这个索引，就存入一个已完成的future，供后续请求直接获取。

具体实现细节 #

核心成员变量 #

private final ConcurrentHashMap<Long, CompletableFuture<T>> futureMap = new ConcurrentHashMap<>();
private final AtomicLong maxKnownIndex = new AtomicLong(-1);

nextEvent(long fromIndex)方法实现 #

public T nextEvent(long fromIndex) throws InterruptedException, ExecutionException {
    long currentIndex = fromIndex;
    while (true) {
        // 尝试获取当前索引对应的事件future
        CompletableFuture<T> future = futureMap.get(currentIndex);
        if (future != null) {
            return future.get();
        }

        // 检查当前索引是否超过已知最大索引，避免无限循环
        long currentMax = maxKnownIndex.get();
        if (currentIndex > currentMax) {
            // 原子化创建并放入future，避免多线程重复创建
            CompletableFuture<T> newFuture = new CompletableFuture<>();
            CompletableFuture<T> existing = futureMap.putIfAbsent(currentIndex, newFuture);
            future = existing != null ? existing : newFuture;
            return future.get();
        }

        // 索引存在间隙，尝试下一个索引
        currentIndex++;
    }
}

append(T event)方法实现（假设append成功后可获取对应索引eventIndex） #

public boolean append(T event, long eventIndex) {
    // 替换为实际存储失败判断逻辑
    if (/* 存储失败条件 */) {
        return false;
    }

    // 更新已知的最大索引
    maxKnownIndex.updateAndGet(currentMax -> Math.max(currentMax, eventIndex));

    // 完成对应索引的future，唤醒所有等待线程
    CompletableFuture<T> future = futureMap.get(eventIndex);
    if (future != null) {
        future.complete(event);
    } else {
        // 无等待线程时，直接存入已完成的future
        futureMap.put(eventIndex, CompletableFuture.completedFuture(event));
    }
    return true;
}

方案优势 #

• 资源高效：无需频繁创建CountDownLatch，仅当有线程等待时才生成CompletableFuture，无等待线程时直接存储已完成的future，避免资源浪费。
• 批量唤醒：CompletableFuture完成时，所有等待该future的线程会被同时唤醒，和CountDownLatch的批量唤醒能力一致，且无需额外锁开销。
• 逻辑简化：依赖ConcurrentHashMap的线程安全特性和原子变量处理索引，无需同时维护读写锁和Latch，代码逻辑更清晰。
• 间隙处理自然：nextEvent会自动跳过未就绪的间隙索引，找到首个就绪的事件，完全匹配需求中的间隙处理要求。

补充说明 #

• 如果append时无法预先确定eventIndex，需要先明确索引生成逻辑（比如用原子变量递增，但要处理失败回滚的情况）。
• 可定期清理futureMap中已处理的旧索引，避免内存泄漏——比如记录已处理的最小索引，移除小于该索引的future条目。

内容的提问来源于stack exchange，提问作者john16384