lifallen
lifallen

揭秘 CompletedFuture 的设计精髓（深入实现分析）

CompletionStage 接口说明见 Java异步编程：CompletionStage接口详解-CSDN博客

基本流程理解见：揭秘 CompletedFuture 的设计精髓（基础）-CSDN博客

成员变量：

  1. volatile Object result

    • 作用：存储异步任务的结果或异常（通过 AltResult 封装）。
    • 编码规则：
      • 正常结果直接存储（null 编码为 NIL）。
      • 异常通过 AltResult 包装（如 new AltResult(ex)）。
    • 原子性保证：通过 RESULT.compareAndSet(this, null, r) 实现无锁更新。

  2. volatile Completion stack

    • 作用：维护依赖操作的 Treiber 栈结构，所有依赖此结果的阶段（Completion）按 LIFO 顺序触发。
    • Completion 类型：
      • 单源依赖（UniCompletion）：如 thenApply、thenAccept。
      • 双源依赖（BiCompletion）：如 thenCombine、thenAcceptBoth。
      • 信号处理（Signaller）：用于阻塞等待线程（如 get() 的阻塞唤醒）。

Treiber 栈，实际上可以理解为一个 从头部CAS插入和删除的链表

Completion 是一个链表节点，有 next 字段。

stack 是一个由 Completion.next 构成的单向链表（栈），如下：

stack → C3 → C2 → C1 → null

每个 Completion 节点代表一个未执行的操作（如 thenApply），一旦完成就从栈中弹出并执行。

实际上，CompletableFuture形成了一个有向无环图(DAG)结构：

  • 单输入操作(如thenApply)：形成链式结构
  • 双输入操作(如thenCombine)：形成汇聚结构（通过CoCompletion转发到同一个节点）
  • anyOf 形成了逻辑上的多个或边；allOf 形成了逻辑的多汇聚（但实际实现是 一个二叉树）

每个CompletableFuture都有自己的stack，存储依赖于它的Completion链表。

Completion 

Completion 作为 CompletableFuture 的依赖操作载体，通过 Treiber 栈组织依赖关系，结合无锁化和异步触发机制，实现了高效的异步任务流水线。其子类（如 UniApply、BiApply）针对不同场景封装逻辑，而 tryFire 和 postComplete 构成了核心的触发链路。

  • 继承关系：

    abstract static class Completion extends ForkJoinTask implements Runnable, AsynchronousCompletionTask

    • 作为 ForkJoinTask，支持异步任务提交（通过 ForkJoinPool）。
    • 作为 Runnable，可直接被线程池执行（如 executor.execute(completion)）。
    • AsynchronousCompletionTask 是标记接口，用于调试和监控。

  • 关键字段与方法：

    volatile Completion next;  // Treiber栈的链表指针
abstract CompletableFuture tryFire(int mode);  // 触发依赖操作
abstract boolean isLive(); // 判断节点是否有效
  • next：构建 Treiber 栈结构，链式存储依赖关系。
  • tryFire：核心抽象方法，由子类实现具体逻辑（如应用函数、合并结果等）。
  • isLive：用于清理无效节点（如已取消的任务）

Completion 的子类分为两类：单源依赖（UniCompletion）和多源依赖（BiCompletion）。

(1) 单源依赖：UniCompletion

abstract static class UniCompletion extends Completion {
    Executor executor;          // 执行器（可能为null）
    CompletableFuture dep;   // 依赖此操作的目标CompletableFuture
    CompletableFuture src;   // 源CompletableFuture
    // ...
}

  • 典型子类：

    • UniApply：对应 thenApply，应用函数 Function。
    • UniAccept：对应 thenAccept，消费结果 Consumer。
    • UniRun：对应 thenRun，执行 Runnable。

  • 触发流程：

    • 当 src（源）完成时，调用 tryFire： 
      if (src.result != null && dep.result == null) {
    d.completeValue(fn.apply(src.result)); // 执行函数并完成依赖
}

(2) 双源依赖：BiCompletion

java

abstract static class BiCompletion extends UniCompletion { CompletableFuture snd; // 第二个源 // ... }

  • 典型子类：

    • BiApply：对应 thenCombine，合并两个结果 BiFunction。
    • BiAccept：对应 thenAcceptBoth，双消费 BiConsumer。
    • BiRun：对应 runAfterBoth，双源完成后执行 Runnable。

  • 触发流程：

    • 需检查两个源（src 和 snd）是否均完成：
if (src.result != null && snd.result != null) {
    d.completeValue(fn.apply(src.result, snd.result));
}

Completion 和 CompletableFuture 共同构建了一个依赖链的 Treiber 栈结构：

  1. 依赖注册：

    • 当调用 thenApply、thenCombine 等方法时，创建对应的 Completion 节点。
    • 节点被推入源 CompletableFuture 的 stack（通过 unipush 或 bipush）。

    void unipush(Completion c) { while (!tryPushStack(c)) { /* CAS竞争入栈 */ } }

  2. 结果触发：

    • 源完成时（complete、completeExceptionally），调用 postComplete() 遍历栈：

      java

      while ((h = stack) != null) {
    stack = h.next;  // 弹出节点
    h.tryFire(SYNC); // 触发依赖操作
}
    • tryFire 会根据模式（SYNC、ASYNC）决定同步执行或提交到线程池。

  3. 异步执行：

    • 若 Completion 包含 executor，其 run() 方法会委托给线程池：

      public void run() { tryFire(ASYNC); } // 通过executor异步执行

设计模式与优势

  1. 观察者模式：

    • CompletableFuture 是被观察者，Completion 是观察者节点。
    • 观察者（依赖操作）在源完成时被通知（通过 postComplete）。

  2. 无锁栈管理：Treiber 栈通过 volatile 和 CAS（STACK.compareAndSet）实现线程安全。

  3. 灵活的任务链：支持单源、多源、异步、异常处理等多种组合方式。


    Completion 与 CompletableFuture 的嵌套关系

    当调用 thenApply 时，实际上会生成一个新的 CompletableFuture 作为目标 Future（dep），用于保存当前阶段的操作结果。例如：

    CompletableFuture future = CompletableFuture.supplyAsync(() -> "hello"); CompletableFuture future2 = future.thenApply(s -> s.length());

    • future.thenApply(...) 创建了一个新的 CompletableFuture（future2）。
    • 这个新 Future 是 UniApply 的目标（dep 字段），而 future 是源（src 字段）。

    源 Future (future)        目标 Future (future2)
      |                          |
      v                          v
   [stack] → [UniApply] → [UniApply.dep = future2]

    • UniApply 节点：
      • src：源 Future（future）。
      • dep：目标 Future（future2）。
      • fn：用户传入的函数（s -> s.length()）。

    当 future 完成时，UniApply 节点的 tryFire(...) 会执行函数，并将结果写入 future2。此时，如果 future2 后续有 thenApply，会继续创建新的 Completion 节点，推入 future2 的栈中。

    CompletableFuture future3 = future
    .thenApply(s -> s.length()) // future2
    .thenApply(i -> i * 2);    // future3

    • 结构：

      future → [UniApply(dep=future2)] → future2 → [UniApply(dep=future3)] → future3

    • 执行流程：

      1. future 完成后，触发 UniApply 节点。
      2. UniApply 执行 s -> s.length()，结果写入 future2。
      3. future2 完成后，触发其栈中的 UniApply 节点。
      4. UniApply 执行 i -> i * 2，结果写入 future3。

    如果多次调用就会形成一个嵌套链表，这也是postComplete为什么会那样写，因为要循环处理这样的结构需要回溯。

    f2 = f1.ThenApply(a)
f3 = f2.ThenApply(b)
f4 = f1.ThenApply(c)
f5 = f4.ThenApply(c)

f1.stack → [ThenApply(dep=f4)] → [ThenApply(dep=f2)] → null
f2.stack → [ThenApply(dep=f3)] → null
f4.stack → [ThenApply(dep=f5)] → null

      thenApply 全流程源码级解析

      CompletableFuture src = CompletableFuture.supplyAsync(() -> 1); CompletableFuture dep = src.thenApply(i -> i.toString());

      • 流程分解：
        1. thenApply 创建 UniApply 节点，推入 src.stack。
        2. src 完成后，触发 UniApply.tryFire，将 i.toString() 结果写入 dep。
        3. 若 thenApplyAsync 指定了线程池，则通过 executor.execute(node) 异步执行。

      • thenApply 方法定义：
      public  CompletableFuture thenApply(Function fn) {
    return uniApplyStage(null, fn); // 同步执行
}


      创建依赖阶段 (uniApplyStage)

      private  CompletableFuture uniApplyStage(
    Executor e, Function f) {
    if (f == null) throw new NullPointerException();
    CompletableFuture d = newIncompleteFuture(); // 创建目标Future
    Object r;
    if ((r = result) != null)   // 源已完成的快速路径
        d.uniApplyNow(r, e, f); // 直接同步执行函数
    else
        unipush(new UniApply(e, d, this, f)); // 创建依赖节点并入栈
    return d;
}
      • 关键步骤：
        • newIncompleteFuture()：创建目标 CompletableFuture（dep）。
        • 结果检查：若源已完成（result != null），直接同步执行函数。
        • 未完成时：创建 UniApply 节点并推入栈（unipush）。

      构建 UniApply 节点

      @SuppressWarnings("serial")
static final class UniApply extends UniCompletion {
    Function fn;
    UniApply(Executor executor, CompletableFuture dep,
             CompletableFuture src,
             Function fn) {
        super(executor, dep, src); // 父类初始化
        this.fn = fn;
    }
    // ...
}
      • 继承结构：
        • UniApply → UniCompletion → Completion。
      • 关键字段：
        • executor：异步执行时使用的线程池（可能为 null）。
        • dep：依赖此操作的目标 Future（dep）。
        • src：源 Future（src）。
        • fn：用户传入的函数。

      推入 Treiber 栈 (unipush)

      final void unipush(Completion c) {
    if (c != null) {
        while (!tryPushStack(c)) { // CAS竞争入栈
            if (result != null) {  // 源突然完成时终止循环
                NEXT.set(c, null); // 清理next指针
                break;
            }
        }
        if (result != null)
            c.tryFire(SYNC); // 立即触发
    }
}

// CAS入栈实现
final boolean tryPushStack(Completion c) {
    Completion h = stack;
    NEXT.set(c, h);         // c.next = h
    return STACK.compareAndSet(this, h, c); // stack = c
}

      • 无锁栈操作：
        • 通过 STACK.compareAndSet 原子性更新栈顶。
        • 若入栈过程中源突然完成（result != null），直接触发 tryFire(SYNC)。

      complete时发生了什么

      源完成触发依赖 (postComplete)

      当源 Future (src) 完成时（如调用 complete(42)）：

      postComplete() 的作用是：
      遍历当前 future 和其依赖 future 的 Completion 栈，依次弹出 Completion 并执行，直到所有 Completion 处理完毕。
      它利用 CAS 实现无锁并发，利用栈结构支持链式 Completion，通过 tryFire 触发下游操作，最终实现高效的异步回调链执行机制。

      public boolean complete(T value) {
    boolean triggered = completeValue(value); // CAS设置result
    postComplete(); // 触发所有依赖节点
    return triggered;
}

final void postComplete() {
    CompletableFuture f = this;
    while ((h = f.stack) != null || (f != this && (h = (f = this).stack) != null)) {
        CompletableFuture d; Completion t;
        if (STACK.compareAndSet(f, h, t = h.next)) { // 弹出栈顶
            if (t != null) {
                if (f != this) {
                    pushStack(h); // 处理嵌套依赖
                    continue;
                }
                NEXT.compareAndSet(h, t, null); // 断开链表
            }
            f = (d = h.tryFire(NESTED)) == null ? this : d; // 触发操作
        }
    }
}

      • 核心流程：
        • 循环弹出栈顶节点（h），调用 h.tryFire(NESTED)。
        • tryFire 返回非空时，处理新生成的依赖链（如级联 thenApply）。

      (h = f.stack) != null || (f != this && (h = (f = this).stack) != null)  是 两阶段扫描：

      1. 第一阶段：从当前 future (f) 的栈中取 Completion；
      2. 第二阶段：如果当前栈空了，回到原始 future (this) 再次取一次；
      3. 目的：确保所有嵌套 Completion 都能被执行。

      t != null && f != this  表示：

      • 当前 Completion 有后续节点（t != null）；
      • 但当前处理的是嵌套 future（f != this）；
      • 所以要把当前 Completion 压回去，留给后续处理。

      否则会导致后续 Completion 被跳过，导致任务丢失。

      当 dep 完成时，需要触发 dep 自己的栈。例如：

      CompletableFuture future3 = future2.thenApply(i -> i * 2);

      • future2 完成后，UniApply 节点的 tryFire(...) 会返回 future3。
      • postComplete() 会切换到 future3 的栈，继续触发后续操作。

      f = (d = h.tryFire(NESTED)) == null ? this : d;

      • d = h.tryFire(...)：返回 dep（如 future2）。
      • f = d：切换到 dep 的栈，继续处理它的 Completion 节点。

      执行依赖操作 (UniApply.tryFire)

      final CompletableFuture tryFire(int mode) {
    CompletableFuture d;
    CompletableFuture a;
    Object r; Throwable x; Function f;
    if ((a = src) == null || (r = a.result) == null
        || (d = dep) == null || (f = fn) == null)
        return null; // 参数未就绪时退出
    try {
        if (mode <= 0 && !claim()) // 检查是否可执行（CAS标记）
            return null;
        if (r instanceof AltResult) { // 异常处理
            if ((x = ((AltResult)r).ex) != null) {
                d.completeThrowable(x, r);
                return d.postFire(a, mode);
            }
            r = null;
        }
        @SuppressWarnings("unchecked") T t = (T) r;
        d.completeValue(f.apply(t)); // 应用函数并完成目标Future
    } catch (Throwable ex) {
        d.completeThrowable(ex);
    }
    src = null; dep = null; fn = null; // 清理引用
    return d.postFire(a, mode); // 继续触发后续依赖
}

      • 关键步骤：
        • claim()：通过 CAS 标记任务已被认领，防止重复执行。
        • 异常检查：若源结果包含异常，直接传播到 dep。
        • 函数应用：f.apply(t) 执行用户逻辑，结果写入 dep。
        • 清理资源：断开与源 Future 的引用，防止内存泄漏。

      异步执行路径

      若调用 thenApplyAsync（指定 executor）：

      public  CompletableFuture thenApplyAsync(Function fn) {
    return uniApplyStage(defaultExecutor(), fn); // 传递线程池
}

// UniApply执行时：
if (e != null) {
    e.execute(new UniApply(null, d, this, f)); // 提交到线程池
} else {
    // 同步执行（同前）
}

      • 异步触发：
        • UniApply 作为 Runnable 被提交到线程池。
        • 其 run() 方法调用 tryFire(ASYNC)，逻辑与同步模式一致。

      最终结果传递

      • 同步完成：
        • d.completeValue(f.apply(t)) 直接设置结果，触发 dep 的 postComplete()。
      • 异步完成：
        • 由线程池线程调用 tryFire(ASYNC)，其余逻辑相同。

      设计总结

      1. 依赖链结构：

        • 每个 thenApply 创建一个 UniApply 节点，形成 Treiber 栈链。
        • 栈结构确保依赖按注册顺序 LIFO 触发（后注册先执行）。

      2. 无锁化实现：

        • 通过 volatile 和 CAS 实现栈操作的线程安全。
        • claim() 方法避免多个线程重复执行同一节点。

      3. 异常传播：

        • 异常通过 AltResult 包装，在 tryFire 中自动传播到下游。

      4. 资源管理：

        • 完成后的节点会清理 src、dep 引用，辅助 GC 回收。
        • postFire 中调用 cleanStack() 移除无效节点。

      双源 Completion（如 thenCombine）的结构与执行流程

      示例代码：

      CompletableFuture f1 = CompletableFuture.supplyAsync(() -> 100); 
CompletableFuture f2 = CompletableFuture.supplyAsync(() -> "Hello"); 
CompletableFuture f3 = f1.thenCombine(f2, (i, s) -> s + i);

      结构图：

      f1.stack → [BiApply(dep=f3, snd=f2)] → null

      f2.stack → [CoCompletion(base=BiApply)] → null

      实现类关系：

      • BiApply：处理两个源的结果，执行 BiFunction。
      • CoCompletion：辅助类，指向第一个源的 Completion，用于第二个源完成后唤醒整个操作。

      三、thenCombine 的完整执行流程详解

      f1.bipush(f2, new BiApply<>(e, d, this, b, f));

      • bipush(...) 内部会将 BiApply 推入 f1 的栈，并创建 CoCompletion 推入 f2 的栈。

      class CoCompletion extends Completion {
    BiCompletion base;
    final CompletableFuture tryFire(int mode) {
        return base.tryFire(mode); // 转发给 BiApply
    }
}

      • 这样当 f2 完成时，也能触发 BiApply。

      步骤 3：任意源完成都会尝试触发

      当 f1 或 f2 完成时，各自调用 postComplete()，尝试从各自的栈中取出 Completion 并执行。

      以 f1 完成为例：

      • f1 的栈中有 BiApply 节点。
      • BiApply.tryFire(...) 会检查 f1.result != null && f2.result != null。
      • 如果两个源都完成了，则执行 fn.apply(t, s) 并完成 f3。

      如果 f1 先完成，但 f2 还没完成：

      if ((r instanceof AltResult && ((AltResult)r).ex != null) ||
    (s instanceof AltResult && ((AltResult)s).ex != null)) {
    d.completeThrowable(...); // 异常处理
} else if (r == null || s == null) {
    return false; // 有一个未完成，不能执行
}

      不执行，等待 f2 完成后再次触发。

      双源 Completion 并不是简单的链表结构，而是一种 双向监听 + 协作完成机制。

      原因：

      • Java 的 CompletableFuture 支持 任意顺序完成，即：
        • f1 先完成，f2 后完成；
        • f2 先完成，f1 后完成；
      • 所以每个 Completion 都要能独立判断是否可以执行。

      设计方案：

      • 主节点：BiApply 节点被推入 f1 的栈。
      • 辅助节点：CoCompletion 节点被推入 f2 的栈，指向 BiApply。
      • 协作逻辑：
        • 当 f1 完成时，检查 f2 是否也完成，若完成则执行。
        • 若 f2 未完成，则等待其完成后再触发。
        • 同理，f2 完成时也会触发 CoCompletion，再转发到 BiApply。

      f1.stack → [BiApply(dep=f3, src=f1, snd=f2, fn)]

      f2.stack → [CoCompletion(base=BiApply)]

      当 f1 完成时：

      • BiApply.tryFire(...) 检查 f2 是否也完成。
      • 如果是，执行 fn.apply(...), 完成 f3。

      当 f2 完成时：

      • CoCompletion.tryFire(...) 转发到 BiApply.tryFire(...)。
      • 同样检查 f1 是否完成，若完成则执行。

      问题背景：

      • BiApply 是属于 f1 的 Completion。
      • f2 也需要知道这个操作的存在，否则它完成时无法触发 BiApply。

      解决方案：

      • 在 f2 上注册一个轻量级代理节点 CoCompletion，它不执行任何操作，只是把控制权转交给 BiApply。
       
  
      class CoCompletion extends Completion {
    BiCompletion base;

    final CompletableFuture tryFire(int mode) {
        return base.tryFire(mode); // 转发到 BiApply
    }

    final boolean isLive() { return base != null && base.dep != null; }
}
       
  
       
  
       
  
         
   
      • f1 完成 → 直接执行 BiApply。
        •  
   
      • f2 完成 → 触发 CoCompletion → 转发到 BiApply。
        •  
   
      • 确保无论哪个源先完成，都能正确处理。
        •  
  
       
  
       
  
       
  
      总体理解：
       
  
         
   
      • tryFire(...) 是所有 Completion 的统一入口，负责判断是否可执行，并实际执行用户逻辑。
        •  
   
      • 单源 Completion（如 thenApply）只需要一个 Completion 节点。
        •  
   
      • 双源 Completion（如 thenCombine）需要两个 Completion 节点： 
    
           
     
        • 主节点 BiApply 注册在第一个源上。
          •  
     
        • 代理节点 CoCompletion 注册在第二个源上，仅转发控制权。
          •  
    
         
        •  
  
       
  
       
  
       
  
      postComplete/tryFire 的逻辑解析
       
  
      tryFire 和 postCompletion 这两个函数之前进行过一些分析，但因为两者逻辑上是令人困惑的，所以这里做一次总结。
       
  
      解释令人困惑的代码：
       
  
      while ((h = f.stack) != null ||
       (f != this && (h = (f = this).stack) != null)) {
    CompletableFuture d; Completion t;
    if (STACK.compareAndSet(f, h, t = h.next)) {
        if (t != null) {
            if (f != this) {
                pushStack(h);  // 关键：为什么要放回去？
                continue;
            }
            NEXT.compareAndSet(h, t, null);
        }
        f = (d = h.tryFire(NESTED)) == null ? this : d;  // 关键：返回值含义
    }
}

       
  
       
  
      postComplete方法负责在CompletableFuture完成后触发所有依赖的Completion。它的核心逻辑是：
       
  
         
   
      1. 从stack中弹出Completion节点
        2.  
   
      2. 调用每个Completion的tryFire(NESTED)方法
        3.  
   
      3. 处理可能的链式传播
        4.  
  
       
  
       
  
      tryFire方法有三种模式：
       
  
         
   
      • SYNC (0): 同步模式，直接执行
        •  
   
      • ASYNC (1): 异步模式，通过线程池执行
        •  
   
      • NESTED (-1): 嵌套模式，用于避免无限递归
        •  
  
       
  
      NESTED模式是为了解决递归调用问题。当一个Completion完成后，可能触发其他Completion的完成，形成链式反应。如果每次都直接调用postComplete，会导致栈溢出。postComplete调用tryFire时使用NESTED模式
       
  
      tryFire在NESTED模式下
       
  
      情况1：返回null。表示这个Completion处理完毕，没有需要继续传播的CompletableFuture。f 被设置为this，继续处理当前CompletableFuture的其他Completion
       
  
      情况2：返回 Completion中dep字段指向的CompletableFuture，即下一个需要处理的CompletableFuture。
       
  
      postComplete通过循环而非递归来处理这个返回值
       
  
          final CompletableFuture tryFire(int mode) {
        // ... 执行逻辑后
        return dep.postFire(src, mode);  // 返回dep，即下一个CompletableFuture
    }
    final CompletableFuture postFire(CompletableFuture a, int mode) {
        if (a != null && a.stack != null) {
            Object r;
            if ((r = a.result) == null)
                a.cleanStack();
            // NEST == -1 不走这
            if (mode >= 0 && (r != null || a.result != null))
                a.postComplete();
        }
        if (result != null && stack != null) {
            if (mode < 0)
                return this;
            else
                postComplete();
        }
        return null;
    }
       
  
       
  
       
  
      pushStack"放回去"的原因
       
  
      if (f != this) {
    pushStack(h);
    continue;
}

       
  
      这里的逻辑是：
       
  
         
   
      • 当前处理的不是最初的CompletableFuture (this)
        •  
   
      • 而是在处理传播链中的其他CompletableFuture (f)
        •  
   
      • 将Completion h放回到 当前CompletableFuture(this) 的stack上
        •  
   
      • 这样确保所有需要处理的Completion最终都在原始的this上排队处理
        •  
  
       
  
       
  
      举一个例子，用Completion结构表示：
       
  
      f1.stack -> [Completion1{dep:f2}] -> [Completion2{dep:f3}] -> null
f2.stack -> [Completion3{dep:f4}] -> [Completion4{dep:f5}] -> null
f4.stack -> [Completion5{dep:f6}] -> null

       
  
      postComplete执行过程
       
  
      如果没有"放回去"机制，执行路径是：
       
  
      f1(this)
f1 → f2 → f4 → f6
f1 → f3 (结束)

       
  
      遗漏的依赖：
       
  
         
   
      • Comp4{dep:f5}：f2→f5的依赖链
        •  
  
       
  
      当f != this时（即当前处理的不是原始的f1），执行pushStack(h)将未处理的Completion放回f1的stack中。经过"放回去"机制，f1.stack动态变化：
       
  
      初始：f1.stack → [Comp1{f2}] → [Comp2{f3}] → null
       
  
      处理Comp1后：
       
  
      f1.stack → [Comp2{f3}] → null
       
  
      现在 f=f2，f2.stack → [Comp3{f4}] → [Comp4{f5}] → null
       
  
      处理f2的栈时：Comp3{f4}会被放回f1.stack
       
  
         
   
      • f1.stack → [Comp3{f4}] → [Comp2{f3}] → null
        •  
   
      • f2.stack →[Comp4{f5}] → null
        •  
   
      • 现在还在 f = f2，因此继续处理Comp4{f5}，因为这是最后一个，不会压入 f1的栈，直接执行。
        •  
  
       
  
      最终保证所有依赖链都被正确处理。
       
  
      这里是为了满足能够通过循环遍历图，如果使用递归则没必要这样处理。
       
  
       为什么需要claim()
       
  
      虽然stack是通过CAS操作维护的链表，但这只保证了链表结构的一致性，不能保证Completion执行的唯一性。问题在于：
       
  
         
   
      1. 多线程竞争执行: 同一个Completion可能被多个线程同时触发
        2.  
   
      2. 重复执行风险: 没有claim()的话，一个Completion可能被执行多次
        3.  
  
       
  
       
  
      claim()方法使用ForkJoinTask的tag位作为原子标记：
       
  
      final boolean claim() {
    Executor e = executor;
    if (compareAndSetForkJoinTaskTag((short)0, (short)1)) {
        if (e == null)
            return true;
        executor = null; // disable
        e.execute(this);
    }
    return false;
}

       
  
      这里使用了ForkJoinTask的tag字段作为CAS标记，确保只有一个线程能成功claim这个Completion。
       
  
      CAS操作在这里分两个层面：
       
  
         
   
      1. stack链表的CAS: 保证链表结构操作的原子性（如tryPushStack、STACK.compareAndSet）
        2.  
   
      2. Completion执行的CAS: 通过claim()方法保证每个Completion只被执行一次
        3.  
  
       
  
      例如
       
  
      CompletableFuture cf1 = new CompletableFuture<>();
CompletableFuture cf2 = cf1.thenApply(String::length);

// 在不同线程中
cf1.complete("hello");  // 线程A
cf1.complete("world");  // 线程B (尝试但不会成功)
       
  
      这种情况，两个线程会取执行 包含 cf2 的Completion。另一种情况是thencombine，这里有天然的多线程操作后继 Completion的操作。
       
  
       
  
      stack的CAS保证了链表操作的原子性，而claim()保证了业务逻辑执行的唯一性，两者配合实现了完整的并发安全保障。
       
  
       
  
      在 tryFire 方法中，关键代码是：
       
  
      try {
    if (mode <= 0 && !claim())
        return null;
    else {
        @SuppressWarnings("unchecked") T t = (T) r;
        d.completeValue(f.apply(t));
    }
} catch (Throwable ex) {
    d.completeThrowable(ex);
}

       
  
      claim 在ASYNC模式没有被调用，可以通过整个链路来理解：
       
  
       完整的 thenApplyAsync 调用链路
       
  
         
   
      1. 用户调用 future.thenApplyAsync(fn)
        2.  
   
      2. thenApplyAsync 调用 uniApplyStage(defaultExecutor(), fn)
        3.  
   
      3. uniApplyStage 创建新的 CompletableFuture 和 UniApply Completion。uniApplyStage 中如果有结果会进行 uniApplyNow，直接计算（根据是不是异步，交给线程池）。 
    
           
     
        1. unipush中，如果有结果会进行tryFire(SYNC)，这之后的调用和postComplete类似，但会调用到postComplete，因为要触发之后的调用，之后使用NEST模式，不会再递归调用postComplete。
          2.  
     
        2. tryFire(SYNC) ，判断(mode <= 0 && !claim()) 会通过，因此返回null，把执行交给线程池 e，claim返回 flase，导致 tryFire 直接 return null。
          3.  
    
         
        4.  
   
      4. UniApply Completion 通过 unipush 方法添加到源 CompletableFuture 的栈中
        5.  
   
      5. 当源 CompletableFuture 完成时: 
    
           
     
        • 调用 postComplete() 方法
          •  
     
        • postComplete() 弹出栈中的 Completion 并调用 tryFire(NESTED)
          •  
     
        • UniApply.tryFire(NESTED) 通过 claim() 方法提交自身到执行器
          •  
     
        • 执行器执行 Completion 的 run() 方法
          •  
     
        • run() 调用 tryFire(ASYNC)
          •  
     
        • tryFire(ASYNC) 直接执行函数而不再检查 claim()
          •  
     
        • 执行结果用于完成目标 CompletableFuture
          •  
    
         
        6.  
  
       
  
      现在我们可以清楚地理解：
       
  
         
   
      1.  
        tryFire(ASYNC) 的调用时机：当 Completion 被执行器异步执行时，通过 run() 或 exec() 方法调用 tryFire(ASYNC)
         
        2.  
   
      2.  
        claim() 方法的作用：
         
    
           
     
        • 使用 CAS 操作确保 Completion 只被一个线程处理
          •  
     
        • 如果有执行器，将 Completion 提交到执行器异步执行，并返回 false
          •  
    
         
        3.  
   
      3.  
        为什么 ASYNC 模式不需要 claim：
         
    
           
     
        • 当以 ASYNC 模式调用 tryFire 时，Completion 已经在执行器线程中运行
          •  
     
        • claim() 的两个目的（确保单线程处理和提交到执行器）在 ASYNC 模式下都不再需要
          •  
    
         
        4.  
  
       
  
       
  
       
  
      tryFire
       
  
       
  
      tryFire方法有三种模式：
       
  
       
  
         
   
      • SYNC (0): 同步模式，直接在当前线程执行
        •  
   
      • ASYNC (1): 异步模式，在线程池中执行
        •  
   
      • NESTED (-1): 嵌套模式，用于避免递归调用栈溢出
        •  
  
       
  
      NESTED在postComplete中分析了
       
  
      SYNC模式的调用时机
       
  
      1.1 UniCompletion中的SYNC调用
       
  
      在unipush方法中，当CompletableFuture已经完成时：
       
  
      if (result != null)
    c.tryFire(SYNC);

       
  
      这种情况下，由于源CompletableFuture已经有结果，可以立即同步执行Completion。
       
  
      1.2 BiCompletion中的SYNC调用
       
  
      在bipush方法中，当两个源都已完成时：
       
  
          final void bipush(CompletableFuture b, BiCompletion c) {
        if (c != null) {
            while (result == null) {
                if (tryPushStack(c)) {
                    if (b.result == null)
                        b.unipush(new CoCompletion(c));
                    else if (result != null) // 检查自己有没有完成
                        c.tryFire(SYNC);
                    return;
                }
            }
            b.unipush(c);
        }
    }
       
  
      当都完成时，直接同步触发BiCompletion。
       
  
      1.3 Or操作中的SYNC调用
       
  
      在orpush方法中：
       
  
       
  
          final void orpush(CompletableFuture b, BiCompletion c) {
        if (c != null) {
            while (!tryPushStack(c)) {
                if (result != null) {
                    NEXT.set(c, null);
                    break;
                }
            }
            if (result != null)
                c.tryFire(SYNC);
            else
                b.unipush(new CoCompletion(c)); // 这里也会判断 b 有没有结束，实现了 or
        }
    }

    final void unipush(Completion c) {
        if (c != null) {
            while (!tryPushStack(c)) {
                if (result != null) {
                    NEXT.set(c, null);
                    break;
                }
            }
            if (result != null)
                c.tryFire(SYNC);
        }
    }
       
  
      当任一源已完成时，立即同步执行OrCompletion。
       
  
      ASYNC模式的调用时机
       
  
       
  
      UniCompletion中的ASYNC调用
       
  
      在UniCompletion的claim方法中：
       
  
      final boolean claim() {
    Executor e = executor;
    if (compareAndSetForkJoinTaskTag((short)0, (short)1)) {
        if (e == null)
            return true;
        executor = null;
        e.execute(this); // 这里会异步调用run()方法，最终调用tryFire(ASYNC)
    }
    return false;
}

       
  
      当Completion需要在指定的Executor中异步执行时，会调用tryFire(ASYNC)。
       
  
      Completion继承自ForkJoinTask，其exec方法：
       
  
       
  
      public final boolean exec() { tryFire(ASYNC); return false; }
public final void run() { tryFire(ASYNC); }

       
  
       
  
      当Completion作为ForkJoinTask执行时，会调用tryFire(ASYNC)。
       
  
       
  
       UniCompletion的执行流程
       
  
      以UniApply为例：
       
  
       
  
      final CompletableFuture tryFire(int mode) {
    // 检查前置条件
    if ((a = src) == null || (r = a.result) == null
        || (d = dep) == null || (f = fn) == null)
        return null;
    
    tryComplete: if (d.result == null) {
        // 处理异常结果
        if (r instanceof AltResult) {
            if ((x = ((AltResult)r).ex) != null) {
                d.completeThrowable(x, r);
                break tryComplete;
            }
            r = null;
        }
        try {
            // 关键：模式判断
            if (mode <= 0 && !claim())
                return null;
            else {
                @SuppressWarnings("unchecked") T t = (T) r;
                d.completeValue(f.apply(t));
            }
        } catch (Throwable ex) {
            d.completeThrowable(ex);
        }
    }
    // 清理引用
    src = null; dep = null; fn = null;
    return d.postFire(a, mode);
}

       
  
      模式判断逻辑：
       
  
         
   
      • mode <= 0（SYNC或NESTED）：需要调用claim()来确保独占执行
        •  
   
      • mode > 0（ASYNC）：直接执行，因为已经在异步环境中
        •  
  
       
  
      BiCompletion的执行流程
       
  
      以BiApply为例：
       
  
      final CompletableFuture tryFire(int mode) {
    // 检查两个源都已完成
    if ((a = src) == null || (r = a.result) == null
        || (b = snd) == null || (s = b.result) == null
        || (d = dep) == null || (f = fn) == null
        || !d.biApply(r, s, f, mode > 0 ? null : this))
        return null;
    
    // 清理引用
    src = null; snd = null; dep = null; fn = null;
    return d.postFire(a, b, mode);
}

       
  
      在biApply方法中：
       
  
       
  
      final  boolean biApply(Object r, Object s,
                           BiFunction f,
                           BiApply c) {
    // 处理异常...
    try {
        if (c != null && !c.claim())  // 当mode <= 0时，c不为null
            return false;
        @SuppressWarnings("unchecked") R rr = (R) r;
        @SuppressWarnings("unchecked") S ss = (S) s;
        completeValue(f.apply(rr, ss));
    } catch (Throwable ex) {
        completeThrowable(ex);
    }
    return true;
}

       
  
       
  
      关键差异：
       
  
         
   
      • mode > 0（ASYNC）：传入null作为Completion参数，跳过claim()检查
        •  
   
      • mode <= 0（SYNC/NESTED）：传入this，需要通过claim()确保独占执行
        •  
  
       
  
       
  
       
  
      Canceller、Signaller、Timeout、anyOf与allOf
       
  
      在前面的讨论中，我们已经了解了CompletableFuture的基本工作机制，包括uni、bi和or操作的执行流程。接下来，我将对CompletableFuture中的其他重要组件和特性进行详细分析。
       
  
       
  
      1. Canceller - 超时取消机制
       
  
      Canceller是一个实现了BiConsumer的内部类，主要用于取消计划任务：
       
  
       
  
      static final class Canceller implements BiConsumer {
    final Future f;
    Canceller(Future f) { this.f = f; }
    public void accept(Object ignore, Throwable ex) {
        if (f != null) // currently never null
            f.cancel(false);
    }
}

       
  
       
  
       
  
         
   
      1.  
        主要用途：用于取消超时任务。当CompletableFuture以其他方式完成时，不再需要超时触发。
         
        2.  
   
      2.  
        工作流程：
         
    
           
     
        • 当设置超时时（如使用orTimeout或completeOnTimeout方法），会创建一个定时任务
          •  
     
        • 同时通过whenComplete注册一个Canceller
          •  
     
        • 如果CompletableFuture在超时前完成，Canceller会取消定时任务
          •  
     
        • 这避免了不必要的超时任务继续占用系统资源
          •  
    
         
        3.  
   
      3.  
        使用示例：在arrangeTimeout方法中可以看到完整流程
         
        4.  
  
       
  
       
  
      private  void arrangeTimeout(long nanoDelay, Timeout onTimeout) {
    ForkJoinPool e = ASYNC_POOL;
    if (result == null) {
        ScheduledForkJoinTask t = new ScheduledForkJoinTask(
            nanoDelay, 0L, true, onTimeout, null, e);
        whenComplete(new Canceller(t));  // 注册Canceller取消器
        e.scheduleDelayedTask(t);
    }
}

       
  
       
  
      2. Timeout - 超时处理机制
       
  
       
  
      Timeout是一个实现了Runnable的内部类，负责在超时发生时执行操作：
       
  
      static final class Timeout implements Runnable {
    final CompletableFuture f;
    final U value;
    final boolean exceptional;
    Timeout(CompletableFuture f, U value, boolean exceptional) {
        this.f = f; this.value = value; this.exceptional = exceptional;
    }
    public void run() {
        if (f != null && !f.isDone()) {
            if (exceptional)
                f.completeExceptionally(new TimeoutException());
            else
                f.complete(value);
        }
    }
}

       
  
      Timeout的工作机制
       
  
         
   
      1.  
        两种工作模式：
         
    
           
     
        • 异常模式(exceptional=true)：超时时以TimeoutException异常完成Future
          •  
     
        • 默认值模式(exceptional=false)：超时时以指定的默认值完成Future
          •  
    
         
        2.  
   
      2.  
        对应的公共API：
         
    
           
     
        • orTimeout(timeout, unit)：超时抛异常
          •  
     
        • completeOnTimeout(value, timeout, unit)：超时使用默认值
          •  
    
         
        3.  
   
      3.  
        执行流程：
         
    
           
     
        • 创建Timeout实例，包含操作模式和可能的默认值
          •  
     
        • 将其作为定时任务提交到调度器
          •  
     
        • 超时触发时，执行run()方法完成CompletableFuture
          •  
    
         
        4.  
  
       
  
      3. Signaller - 阻塞等待机制
       
  
      Signaller是一个特殊的Completion子类，实现了ForkJoinPool.ManagedBlocker接口，用于支持阻塞等待操作：
       
  
         
   
      1.  
        设计：
         
    
           
     
        • 实现ManagedBlocker接口，确保在ForkJoinPool中阻塞时不会导致线程饥饿
          •  
     
        • 支持中断和超时等待
          •  
     
        • 使用LockSupport进行线程挂起和唤醒
          •  
    
         
        2.  
   
      2.  
        等待过程：
         
    
           
     
        • 将Signaller实例推入CompletableFuture的栈
          •  
     
        • 将当前线程记录在Signaller中
          •  
     
        • 通过LockSupport.park或LockSupport.parkNanos挂起线程
          •  
     
        • 当Future完成时，触发Signaller的tryFire方法唤醒等待线程
          •  
    
         
        3.  
   
      3.  
        唤醒机制：
         
    
           
     
        • 当CompletableFuture完成时，会调用postComplete处理栈中的依赖
          •  
     
        • Signaller的tryFire方法会解除线程的阻塞状态
          •  
    
         
        4.  
  
       
  
       
  
          static final class Signaller extends Completion
        implements ForkJoinPool.ManagedBlocker {
        long nanos;                    // remaining wait time if timed
        final long deadline;           // non-zero if timed
        final boolean interruptible;
        boolean interrupted;
        volatile Thread thread;

        Signaller(boolean interruptible, long nanos, long deadline) {
            this.thread = Thread.currentThread();
            this.interruptible = interruptible;
            this.nanos = nanos;
            this.deadline = deadline;
        }
        final CompletableFuture tryFire(int ignore) {
            Thread w; // no need to atomically claim
            if ((w = thread) != null) {
                thread = null;
                LockSupport.unpark(w);
            }
            return null;
        }
        public boolean isReleasable() {
            if (Thread.interrupted())
                interrupted = true;
            return ((interrupted && interruptible) ||
                    (deadline != 0L &&
                     (nanos <= 0L ||
                      (nanos = deadline - System.nanoTime()) <= 0L)) ||
                    thread == null);
        }
        public boolean block() {
            while (!isReleasable()) {
                if (deadline == 0L)
                    LockSupport.park(this);
                else
                    LockSupport.parkNanos(this, nanos);
            }
            return true;
        }
        final boolean isLive() { return thread != null; }
    }
       
  
       
  
      4. anyOf - 任意完成机制
       
  
      anyOf静态方法创建一个在任何输入CompletableFuture完成时完成的新CompletableFuture：
       
  
         
   
      1.  
        核心类：AnyOf Completion类
         
        2.  
   
      2.  
        设计特点：
         
    
           
     
        • 监听多个输入Future中的任何一个
          •  
     
        • 当任一输入完成时，使用相同结果完成输出Future
          •  
     
        • 完成后清理其他输入Future的栈，避免资源泄漏
          •  
    
         
        3.  
   
      3.  
        执行流程：
         
    
           
     
        • 创建一个新的CompletableFuture作为结果
          •  
     
        • 检查所有输入Future，如有已完成则直接使用其结果
          •  
     
        • 对每个输入Future添加AnyOf监听器
          •  
     
        • 当任一输入完成时，触发AnyOf.tryFire方法
          •  
     
        • tryFire调用completeRelay传递结果，并清理其他输入的栈
          •  
    
         
        4.  
   
      4.  
        优化处理：
         
    
           
     
        • 特殊处理空数组和单元素数组的情况
          •  
     
        • 完成后清理其他Future的栈，避免内存泄漏
          •  
     
        • 结果处理使用encodeRelay，保证异常正确传播
          •  
    
         
        5.  
  
       
  
       
  
      anyOf的实现分析
       
  
       
  
      public static CompletableFuture anyOf(CompletableFuture... cfs) {
    int n; Object r;
    if ((n = cfs.length) <= 1)
        return (n == 0)
            ? new CompletableFuture()
            : uniCopyStage(cfs[0]);
    for (CompletableFuture cf : cfs)
        if ((r = cf.result) != null)
            return new CompletableFuture(encodeRelay(r));
    cfs = cfs.clone();
    CompletableFuture d = new CompletableFuture<>();
    for (CompletableFuture cf : cfs)
        cf.unipush(new AnyOf(d, cf, cfs));
    // If d was completed while we were adding completions, we should
    // clean the stack of any sources that may have had completions
    // pushed on their stack after d was completed.
    if (d.result != null)
        for (int i = 0, len = cfs.length; i < len; i++)
            if (cfs[i].result != null)
                for (i++; i < len; i++)
                    if (cfs[i].result == null)
                        cfs[i].cleanStack();
    return d;
}
 
  
       
  
       
  
         
   
      1.  
        边界条件处理：
         
    
           
     
        • 如果传入的CompletableFuture数组长度为0，返回一个新的未完成的CompletableFuture
          •  
     
        • 如果长度为1，则直接返回该CompletableFuture的副本
          •  
    
         
        2.  
   
      2.  
        快速完成检查：
         
    
           
     
        • 遍历所有传入的CompletableFuture，检查是否已有完成的，如果有则立即创建一个已完成的CompletableFuture并返回
          •  
    
         
        3.  
   
      3.  
        注册依赖：
         
    
           
     
        • 克隆输入数组（防止修改原数组）
          •  
     
        • 创建一个新的结果CompletableFuture
          •  
     
        • 为每个源CompletableFuture注册AnyOf完成处理器
          •  
    
         
        4.  
   
      4.  
        清理：
         
    
           
     
        • 如果在注册过程中结果已经完成，清理那些依然未完成的CompletableFuture的栈
          •  
    
         
        5.  
   
      5.  
        AnyOf Completion类：
          
           
        static class AnyOf extends Completion {
    CompletableFuture dep; CompletableFuture src;
    CompletableFuture[] srcs;
    AnyOf(CompletableFuture dep, CompletableFuture src,
          CompletableFuture[] srcs) {
        this.dep = dep; this.src = src; this.srcs = srcs;
    }
    final CompletableFuture tryFire(int mode) {
        // assert mode != ASYNC;
        CompletableFuture d; CompletableFuture a;
        CompletableFuture[] as;
        Object r;
        if ((a = src) == null || (r = a.result) == null
            || (d = dep) == null || (as = srcs) == null)
            return null;
        src = null; dep = null; srcs = null;
        if (d.completeRelay(r)) {
            for (CompletableFuture b : as)
                if (b != a)
                    b.cleanStack();
            if (mode < 0)
                return d;
            else
                d.postComplete();
        }
        return null;
    }
    final boolean isLive() {
        CompletableFuture d;
        return (d = dep) != null && d.result == null;
    }
}
 
    
           
     
        • tryFire方法在源CompletableFuture完成时被调用
          •  
     
        • 将结果传递给依赖的CompletableFuture
          •  
     
        • 清理其他所有源CompletableFuture的栈（这是关键优化，防止无用的栈积累）
          •  
    
          
   
  
         
  
         
  
        5. allOf - 全部完成机制
         
  
         
  
        allOf静态方法创建一个在所有输入CompletableFuture完成时完成的新CompletableFuture：
         
  
           
   
        1.  
          核心方法：andTree - 递归构建完成树
           
          2.  
   
        2.  
          设计特点：
           
    
             
     
          • 使用分治法构建二叉树结构
            •  
     
          • 通过BiRelay节点连接子树
            •  
     
          • 任何异常都会导致结果Future异常完成
            •  
    
           
          3.  
   
        3.  
          执行流程：
           
    
             
     
          • 递归地将输入数组分成左右两半
            •  
     
          • 对每半递归调用andTree，构建子树
            •  
     
          • 使用BiRelay连接左右子树
            •  
     
          • 只有当两个子树都完成时，父节点才会完成
            •  
     
          • 如有任何一个Future异常完成，结果Future也异常完成
            •  
    
           
          4.  
   
        4.  
          优化处理：
           
    
             
     
          • 特殊处理空数组的情况，直接返回完成的Future
            •  
     
          • 使用二分法平衡树结构，提高并行度和效率
            •  
     
          • 优先传播异常，保证快速失败
            •  
    
           
          5.  
  
         
  
        BiRelay是一个特殊的BiCompletion，用于协调两个输入CompletableFuture，只有当两者都完成时才完成依赖的Future。
         
  
        allOf的实现分析
         
  
         
  
        public static CompletableFuture allOf(CompletableFuture... cfs) {
    return andTree(cfs, 0, cfs.length - 1);
}

         
  
         
  
        allOf实际上是调用了andTree方法:
         
  
         
  
        static CompletableFuture andTree(CompletableFuture[] cfs,
                                       int lo, int hi) {
    CompletableFuture d = new CompletableFuture();
    if (lo > hi) // empty
        d.result = NIL;
    else {
        CompletableFuture a, b; Object r, s, z; Throwable x;
        int mid = (lo + hi) >>> 1;
        if ((a = (lo == mid ? cfs[lo] :
                  andTree(cfs, lo, mid))) == null ||
            (b = (lo == hi ? a : (hi == mid+1) ? cfs[hi] :
                  andTree(cfs, mid+1, hi))) == null)
            throw new NullPointerException();
        if ((r = a.result) == null || (s = b.result) == null)
            a.bipush(b, new BiRelay<>(d, a, b));
        else if ((r instanceof AltResult
                  && (x = ((AltResult)(z = r)).ex) != null) ||
                 (s instanceof AltResult
                  && (x = ((AltResult)(z = s)).ex) != null))
            d.result = encodeThrowable(x, z);
        else
            d.result = NIL;
    }
    return d;
}

         
  
         
  
        allOf实现详解：
         
  
           
   
        1.  
          构建二叉树：
           
    
             
     
          • 采用分治策略，将输入的CompletableFuture数组递归地组织成一个完全二叉树
            •  
     
          • 这种树形结构使得任务的并行度最大化
            •  
    
           
          2.  
   
        2.  
          处理边界条件：
           
    
             
     
          • 如果范围为空（lo > hi），则返回一个已完成的结果
            •  
    
           
          3.  
   
        3.  
          递归构建子树：
           
    
             
     
          • 通过中点（mid）划分数组为两部分
            •  
     
          • 递归处理左子树和右子树
            •  
    
           
          4.  
   
        4.  
          状态检查和依赖设置：
           
    
             
     
          • 检查左右子树是否都已完成
            •  
     
          • 如果有任一子树未完成，则设置双向依赖（bipush）
            •  
     
          • 如果都已完成，检查是否有异常，然后相应地完成结果
            •  
    
           
          5.  
   
        5.  
          BiRelay类：
           
          static final class BiRelay extends BiCompletion {
    BiRelay(CompletableFuture dep,
            CompletableFuture src, CompletableFuture snd) {
        super(null, dep, src, snd);
    }
    final CompletableFuture tryFire(int mode) {
        CompletableFuture d;
        CompletableFuture a;
        CompletableFuture b;
        Object r, s, z; Throwable x;
        if (   (a = src) == null || (r = a.result) == null
            || (b = snd) == null || (s = b.result) == null
            || (d = dep) == null)
            return null;
        if (d.result == null) {
            if ((r instanceof AltResult
                 && (x = ((AltResult)(z = r)).ex) != null) ||
                (s instanceof AltResult
                 && (x = ((AltResult)(z = s)).ex) != null))
                d.completeThrowable(x, z);
            else
                d.completeNull();
        }
        src = null; snd = null; dep = null;
        return d.postFire(a, b, mode);
    }
}

           
          6.  
  
         
  
         
  
        encodeRelay/completeRelay
         
  
        encodeRelay主要用于以下场景：
         
  
           
   
        • 当一个CompletableFuture依赖于另一个CompletableFuture的结果时，使用encodeRelay确保异常结果被正确包装为CompletionException，从而保持CompletableFuture的异常处理一致性。
          •  
  
         
  
        假设有两个CompletableFuture f1和f2，f2依赖于f1的结果：
         
  
        CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Error in f1");
});

CompletableFuture f2 = f1.thenApply(result -> {
    // Do something with result
    return result * 2;
});

         
  
        在这种情况下，如果f1异常完成，f2需要正确处理该异常。encodeRelay确保f1的异常结果被传递给f2时，被正确包装为CompletionException。
         
  
        completeRelay 则设置这个包装结果
         
  
            final boolean completeRelay(Object r) {
         
  
                return RESULT.compareAndSet(this, null, encodeRelay(r));
         
  
            }
         
  
         
  
        关键场景分析
         
  
        1. 超时处理场景
         
  
         
  
        // 5秒后超时并抛出异常
CompletableFuture future = someAsyncOperation()
    .orTimeout(5, TimeUnit.SECONDS);

// 5秒后超时并返回默认值
CompletableFuture future = someAsyncOperation()
    .completeOnTimeout("Default value", 5, TimeUnit.SECONDS);

         
  
         
  
        工作流程：
         
  
           
   
        1. 调用arrangeTimeout创建定时任务
          2.  
   
        2. 通过whenComplete注册Canceller取消器
          3.  
   
        3. 如果原始Future在超时前完成，Canceller取消定时任务
          4.  
   
        4. 否则，Timeout.run()方法在超时时执行，完成Future
          5.  
  
         
  
        2. 阻塞等待场景
         
  
         
  
        String result = future.get();  // 可能阻塞直到完成
String result = future.get(10, TimeUnit.SECONDS);  // 带超时的阻塞

         
  
         
  
        工作流程：
         
  
           
   
        1. 创建Signaller实例并记录当前线程
          2.  
   
        2. 将Signaller推入Future的栈中
          3.  
   
        3. 通过LockSupport.park挂起当前线程
          4.  
   
        4. 当Future完成时，触发栈中的Signaller.tryFire
          5.  
   
        5. tryFire唤醒等待线程，继续执行
          6.  
  
         
  
        3. 组合多个Future场景
         
  
         
  
        // 等待所有Future完成
CompletableFuture allDone = CompletableFuture.allOf(future1, future2, future3);

// 等待任一Future完成
CompletableFuture anyDone = CompletableFuture.anyOf(future1, future2, future3);
 
  
         
  
        工作流程(allOf)：
         
  
           
   
        1. 通过andTree递归构建二叉树结构
          2.  
   
        2. 每个节点使用BiRelay连接两个子节点
          3.  
   
        3. 只有当左右子树都完成时，父节点才会完成
          4.  
   
        4. 如有异常，优先传播异常
          5.  
  
         
  
        工作流程(anyOf)：
         
  
           
   
        1. 创建一个新的输出Future
          2.  
   
        2. 为每个输入Future添加AnyOf监听器
          3.  
   
        3. 当任一输入完成，将结果传递给输出Future
          4.  
   
        4. 清理其他Future的栈，避免资源泄漏
          5.  
  
         
  
        总结
         
  
        CompletableFuture的这些高级特性体现了其强大的异步编程能力：
         
  
           
   
        1. 超时机制：通过Timeout和Canceller优雅地实现超时控制，同时避免资源浪费
          2.  
   
        2. 阻塞等待：Signaller结合ManagedBlocker提供安全的阻塞等待，防止线程饥饿
          3.  
   
        3. 组合操作：anyOf和allOf通过巧妙的树状结构，高效实现了多Future协调
          4.  
  
         
  
        这些机制共同构建了CompletableFuture强大且灵活的异步编程模型，使其成为Java中处理复杂异步流程的核心工具。
         
  
         
  
         
  
        CompletableFuture 中获取结果的流程详解
         
  
        CompletableFuture 提供了几种获取计算结果的方法：get()、get(timeout, unit)、join()和getNow()。这些方法的内部实现都涉及 waitingGet、timedGet、reportGet 和 reportJoin 等私有方法。下面详细分析它们的执行流程。
         
  
        1. get() 方法的执行流程
         
  
        当外部使用者调用 CompletableFuture.get() 方法时:
         
  
         
  
        public T get() throws InterruptedException, ExecutionException {
    Object r;
    if ((r = result) == null)
        r = waitingGet(true);
    return (T) reportGet(r, "get");
}

         
  
         
  
        执行步骤：
         
  
           
   
        1. 检查 result 字段是否为 null
          2.  
   
        2. 如果 result 不为 null，表示任务已完成，直接获取结果
          3.  
   
        3. 如果 result 为 null，调用 waitingGet(true) 等待任务完成
          4.  
   
        4. 最后调用 reportGet 方法处理结果并返回
          5.  
  
         
  
        2. waitingGet 方法分析
         
  
        waitingGet 方法实现了阻塞等待任务完成的核心逻辑:
         
  
        private Object waitingGet(boolean interruptible) {
    if (interruptible && Thread.interrupted())
        return null;
    Signaller q = null;
    boolean queued = false;
    Object r;
    while ((r = result) == null) {
        if (q == null) {
            q = new Signaller(interruptible, 0L, 0L);
            if (Thread.currentThread() instanceof ForkJoinWorkerThread)
                ForkJoinPool.helpAsyncBlocker(defaultExecutor(), q);
        }
        else if (!queued)
            queued = tryPushStack(q);
        else if (interruptible && q.interrupted) {
            q.thread = null;
            cleanStack();
            return null;
        }
        else {
            try {
                ForkJoinPool.managedBlock(q);
            } catch (InterruptedException ie) {
                q.interrupted = true;
            }
        }
    }
    if (q != null) {
        q.thread = null;
        if (q.interrupted)
            Thread.currentThread().interrupt();
    }
    postComplete();
    return r;
}

         
  
        执行步骤：
         
  
           
   
        1. 检查线程是否被中断（如果 interruptible 为 true）
          2.  
   
        2. 创建一个 Signaller 实例作为等待节点
          3.  
   
        3. 如果当前线程是 ForkJoinWorkerThread，尝试帮助处理异步阻塞任务
          4.  
   
        4. 将 Signaller 节点推入等待栈中
          5.  
   
        5. 调用 ForkJoinPool.managedBlock(q) 阻塞当前线程
          6.  
   
        6. 当任务完成后（result 不为 null），处理中断状态并调用 postComplete()
          7.  
   
        7. 返回结果
          8.  
  
         
  
        最后一段代码的目的是保留中断状态：
         
  
           
   
        • 当线程在 waitingGet 中等待时，如果发生了中断，Signaller 检测到中断并设置 interrupted = true。
          •  
   
        • 同时 Thread.interrupted() 方法会清除线程的实际中断状态。
          •  
   
        • 方法结束时，该代码段通过 Thread.currentThread().interrupt() 恢复线程的中断状态。
          •  
  
         
  
         
  
        3. Signaller 类的作用
         
  
        Signaller 是 CompletableFuture 中实现线程等待和唤醒机制的关键类：
         
  
           
   
        • Signaller 同时扩展了 Completion 和实现了 ForkJoinPool.ManagedBlocker 接口
          •  
   
        • 它被添加到 CompletableFuture 的等待栈中
          •  
   
        • 当 CompletableFuture 完成时，会调用 tryFire() 方法唤醒等待的线程
          •  
   
        • isReleasable() 判断是否可以结束阻塞状态
          •  
   
        • block() 实现了线程的阻塞逻辑，使用 LockSupport.park/parkNanos
          •  
  
         
  
        4. get(timeout, unit) 和 timedGet 方法
         
  
        带超时参数的 get 方法：
         
  
         
  
        public T get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    long nanos = unit.toNanos(timeout);
    Object r;
    if ((r = result) == null)
        r = timedGet(nanos);
    return (T) reportGet(r, "get");
}

         
  
         
  
        timedGet 方法与 waitingGet 类似，但增加了超时处理：
         
  
        private Object timedGet(long nanos) throws TimeoutException {
    long d = System.nanoTime() + nanos;
    long deadline = (d == 0L) ? 1L : d; // 避免为0
    boolean interrupted = false, queued = false;
    Signaller q = null;
    Object r = null;
    for (;;) { // 检查中断、结果、超时的顺序很重要
        if (interrupted || (interrupted = Thread.interrupted()))
            break;
        else if ((r = result) != null)
            break;
        else if (nanos <= 0L)
            break;
        else if (q == null) {
            q = new Signaller(true, nanos, deadline);
            if (Thread.currentThread() instanceof ForkJoinWorkerThread)
                ForkJoinPool.helpAsyncBlocker(defaultExecutor(), q);
        }
        else if (!queued)
            queued = tryPushStack(q);
        else {
            try {
                ForkJoinPool.managedBlock(q);
                interrupted = q.interrupted;
                nanos = q.nanos;
            } catch (InterruptedException ie) {
                interrupted = true;
            }
        }
    }
    
    // 清理和恢复
    if (q != null) {
        q.thread = null;
        if (r == null)
            cleanStack();
    }
    
    // 根据不同情况返回结果或抛出异常
    if (r != null) {
        if (interrupted)
            Thread.currentThread().interrupt();
        postComplete();
        return r;
    } else if (interrupted)
        return null;
    else
        throw new TimeoutException();
}

         
  
        与 waitingGet 相比，timedGet 增加了：
         
  
           
   
        1. 计算超时截止时间
          2.  
   
        2. 使用超时参数创建 Signaller
          3.  
   
        3. 如果超时返回 null 并抛出 TimeoutException
          4.  
  
         
  
        5. reportGet 和 reportJoin 方法
         
  
        这两个方法处理结果并根据不同情况抛出异常：
         
  
        private static Object reportGet(Object r, String details)
    throws InterruptedException, ExecutionException {
    if (r == null) // 按约定，null表示中断
        throw new InterruptedException();
    if (r instanceof AltResult) {
        Throwable x, cause;
        if ((x = ((AltResult)r).ex) == null)
            return null;
        if (x instanceof CancellationException)
            throw new CancellationException(details, (CancellationException)x);
        if ((x instanceof CompletionException) &&
            (cause = x.getCause()) != null)
            x = cause;
        throw wrapInExecutionException(x);
    }
    return r;
}

private static Object reportJoin(Object r, String details) {
    if (r instanceof AltResult) {
        Throwable x;
        if ((x = ((AltResult)r).ex) == null)
            return null;
        if (x instanceof CancellationException)
            throw new CancellationException(details, (CancellationException)x);
        if (x instanceof CompletionException)
            throw (CompletionException)x;
        throw wrapInCompletionException(x);
    }
    return r;
}

         
  
        关键区别：
         
  
           
   
        • reportGet 抛出受检异常 ExecutionException，用于 get() 方法
          •  
   
        • reportJoin 抛出非受检异常 CompletionException，用于 join() 和 getNow() 方法
          •  
   
        • 对于 null 值的处理不同
          •  
  
         
  
        6. join() 和 getNow() 方法
         
  
        public T join() {
    Object r;
    if ((r = result) == null)
        r = waitingGet(false);
    return (T) reportJoin(r, "join");
}

public T getNow(T valueIfAbsent) {
    Object r;
    return ((r = result) == null) ? valueIfAbsent : (T) reportJoin(r, "getNow");
}

         
  
           
   
        • join() 类似于 get()，但使用 waitingGet(false) 表示不可中断，并使用 reportJoin
          •  
   
        • getNow() 不会等待，如果结果不可用则返回指定的默认值
          •  
  
         
  
        7. 完整流程总结
         
  
           
   
        1. 用户调用 get()/join()/getNow() 方法获取结果
          2.  
   
        2. 检查 result 字段是否为 null
          3.  
   
        3. 如果为 null，通过 waitingGet 或 timedGet 进入等待状态
          4.  
   
        4. 创建 Signaller 对象并添加到等待栈中
          5.  
   
        5. 当前线程通过 ForkJoinPool.managedBlock 或直接 LockSupport.park 阻塞
          6.  
   
        6. 当 CompletableFuture 完成时，会调用 postComplete() 唤醒等待的线程
          7.  
   
        7. 线程醒来后通过 reportGet 或 reportJoin 处理结果
          8.  
   
        8. 根据结果类型返回值或抛出相应异常
          9.  
  
         
  
         
  

                            
                        
                    
                    
                    
        
                    
                    
                    
        
                
                
        
                    
                
        
            
        
    
    
        
        
        你可能感兴趣的:(Java,并发/JUC,数据结构,开发语言,java,算法,数据结构)
        
        
        
            
        
                
          
                    
        • 移动端城市区县二级联动选择功能实现包
                        good2know

                        
          本文还有配套的精品资源，点击获取简介：本项目是一套为移动端设计的jQuery实现方案，用于简化用户在选择城市和区县时的流程。它包括所有必需文件：HTML、JavaScript、CSS及图片资源。通过动态更新下拉菜单选项，实现城市到区县的联动效果，支持数据异步加载。开发者可以轻松集成此功能到移动网站或应用，并可基于需求进行扩展和优化。1.jQuery移动端解决方案概述jQuery技术简介jQuery
          
                    
          • 
                    
        • day15｜前端框架学习和算法
                        universe_01
前端算法笔记
                        
          T22括号生成先把所有情况都画出来，然后（在满足什么情况下）把不符合条件的删除。T78子集要画树状图，把思路清晰。可以用暴力法、回溯法和DFS做这个题DFS深度搜索：每个边都走完，再回溯应用：二叉树搜索，图搜索回溯算法=DFS+剪枝T200岛屿数量（非常经典BFS宽度把树状转化成队列形式，lambda匿名函数“一次性的小函数，没有名字”setup语法糖：让代码更简洁好写的语法ref创建：基本类型的
          
                    
          • 
                    
        • C++ 计数排序、归并排序、快速排序
                        每天搬一点点砖
c++数据结构算法
                        
          计数排序：是一种基于哈希的排序算法。他的基本思想是通过统计每个元素的出现次数，然后根据统计结果将元素依次放入排序后的序列中。这种排序算法适用于范围较小的情况，例如整数范围在0到k之间计数排序步骤：1初始化一个长度为最大元素值加1的计数数组，所有元素初始化为02遍历原始数组，将每个元素值作为索引，在计数数组中对应位置加13将数组清空4遍历计数器数组，按照数组中的元素个数放回到元数组中计数排序的优点和
          
                    
          • 
                    
        • 深入解析JVM工作原理：从字节码到机器指令的全过程
                        

                        
          一、JVM概述Java虚拟机(JVM)是Java平台的核心组件，它实现了Java"一次编写，到处运行"的理念。JVM是一个抽象的计算机器，它有自己的指令集和运行时内存管理机制。JVM的主要职责：加载：读取.class文件并验证其正确性存储：管理内存分配和垃圾回收执行：解释或编译字节码为机器指令安全：提供沙箱环境限制恶意代码二、JVM架构详解JVM由三个主要子系统组成：1.类加载子系统类加载过程分为
          
                    
          • 
                    
        • 【C++算法】76.优先级队列_前 K 个高频单词
                        流星白龙
优选算法C++c++算法开发语言
                        
          文章目录题目链接：题目描述：解法C++算法代码：题目链接：692.前K个高频单词题目描述：解法利用堆来解决TopK问题预处理一下原始的字符串数组，用一个哈希表统计一下每一个单词出现的频次。创建一个大小为k的堆频次：小根堆字典序（频次相同的时候）：大根堆循环让元素依次进堆判断提取结果C++算法代码：classSolution{//定义类型别名，PSI表示对typedefpairPSI;//自定义比较
          
                    
          • 
                    
        • JVM 内存模型深度解析：原子性、可见性与有序性的实现
                        练习时长两年半的程序员小胡
JVM深度剖析：从面试考点到生产实践jvmjava内存模型
                        
          在了解了JVM的基础架构和类加载机制后，我们需要进一步探索Java程序在多线程环境下的内存交互规则。JVM内存模型（JavaMemoryModel，JMM）定义了线程和主内存之间的抽象关系，它通过规范共享变量的访问方式，解决了多线程并发时的数据一致性问题。本文将从内存模型的核心目标出发，详解原子性、可见性、有序性的实现机制，以及volatile、synchronized等关键字在其中的作用。一、J
          
                    
          • 
                    
        • Flowable 高级扩展：自定义元素与性能优化实战
                        练习时长两年半的程序员小胡
Flowable流程引擎实战指南流程图flowableBPMN流程引擎java
                        
          在前五篇文章中，我们从基础概念、流程设计、API实战、SpringBoot集成，到外部系统协同，逐步构建了Flowable的应用体系。但企业级复杂场景中，原生功能往往难以满足定制化需求——比如需要特殊的审批规则网关、与决策引擎联动实现动态路由，或是在高并发场景下优化流程引擎性能。本文将聚焦Flowable的高级扩展能力，详解如何自定义流程元素、集成规则引擎，并掌握大型系统中的性能调优策略。一、自定
          
                    
          • 
                    
        • 什么是缓存雪崩？缓存击穿？缓存穿透？分别如何解决？什么是缓存预热？
                        daixin8848
缓存redisjava开发语言
                        
          缓存雪崩：在一个时间段内，有大量的key过期，或者Redis服务宕机，导致大量的请求到达数据库,带来巨大压力-给key设置不同的TTL、利用Redis集群提高服务的高可用性、添加多级缓存、添加降级流策略缓存击穿：给某一个key设置了过期时间，当key过期的时间，恰好这个时间点有大量的并发请求访问这个key，可能会瞬间把数据库压垮-互斥锁：缓存失败时，只允许一个请求去加载数据并更新缓存，其他请求阻塞
          
                    
          • 
                    
        • Java | 多线程经典问题 - 售票
                        Ada54

                        
          一、售票需求1）同一个票池2）多个窗口卖票，不能出售同一张票二、售票问题代码实现（线程与进程小总结，请戳：Java|线程和进程，创建线程）step1：定义SaleWindow类实现Runnable接口，覆盖run方法step2：实例化SaleWindow对象，创建Thread对象，将SaleWindow作为参数传给Thread类的构造函数，然后通过Thread.start()方法启动线程step3
          
                    
          • 
                    
        • SpringMVC的执行流程
                        

                        
          1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
          
                    
          • 
                    
        • 力扣面试题07 - 旋转矩阵
                        茶猫_
leetcode矩阵算法c语言
                        
          题目：给你一幅由N×N矩阵表示的图像，其中每个像素的大小为4字节。请你设计一种算法，将图像旋转90度。不占用额外内存空间能否做到？示例1:给定matrix=[[1,2,3],[4,5,6],[7,8,9]],原地旋转输入矩阵，使其变为:[[7,4,1],[8,5,2],[9,6,3]]示例2:给定matrix=[[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,
          
                    
          • 
                    
        • JAVA接口机结构解析
                        秃狼
SpringBoot八股文Javajava学习
                        
          什么是接口机在Java项目中，接口机通常指用于与外部系统进行数据交互的中间层，负责处理请求和响应的转换、协议适配、数据格式转换等任务。接口机的结构我们的接口机的结构分为两个大部分，外部接口机和内部接口机，在业务的调度上也是通过mq来实现的，只要的目的就是为了解耦合和做差异化。在接口机中主要的方法就是定时任务，消息的发送和消费，其他平台调用接口机只能提供外部接口机的方法进行调用，外部接口机可以提供消
          
                    
          • 
                    
        • 最新阿里四面面试真题46道：面试技巧+核心问题+面试心得
                        风平浪静如码

                        
          前言做技术的有一种资历，叫做通过了阿里的面试。这些阿里Java相关问题，都是之前通过不断优秀人才的铺垫总结的，先自己弄懂了再去阿里面试，不然就是去丢脸，被虐。希望对大家帮助，祝面试成功，有个更好的职业规划。一，阿里常见技术面1、微信红包怎么实现。2、海量数据分析。3、测试职位问的线程安全和非线程安全。4、HTTP2.0、thrift。5、面试电话沟通可能先让自我介绍。6、分布式事务一致性。7、ni
          
                    
          • 
                    
        • 模拟退火(SA)：如何“故意走错路”，才能找到最优解？
                        小瑞瑞acd
小瑞瑞学数模模拟退火算法python启发式算法算法
                        
          模拟退火(SA)：如何“故意走错路”，才能找到最优解？图示模拟退火算法如何通过接受较差解（橙色虚线标注）从局部最优（绿色点）逃逸，最终找到全局最优解（紫色点），展示其跳出局部极小值的能力。大家好，我是小瑞瑞！欢迎回到我的专栏！想象一下，你站在一座连绵不绝的山脉中，目标是找到海拔最低的那个山谷。你手上只有一个高度计，视野被浓雾笼罩，只能看清脚下的一小片区域。如果你是一个“贪心”的登山者，你的策略会非
          
                    
          • 
                    
        • 编程算法：技术创新的引擎与业务增长的核心驱动力
                        

                        
          在数字经济时代，算法已成为推动技术创新与业务增长的隐形引擎。从存内计算突破冯·诺依曼瓶颈，到动态规划优化万亿级金融交易，编程算法正在重塑产业竞争格局。一、存内计算：突破冯·诺依曼瓶颈的算法革命1.1存内计算的基本原理传统计算架构中90%的能耗消耗在数据搬运上。存内计算（Processing-in-Memory）通过直接在存储单元执行计算，实现能效10-100倍提升：#传统计算vs存内计算能耗模型i
          
                    
          • 
                    
        • 图论算法经典题目解析：DFS、BFS与拓扑排序实战
                        周童學
数据结构与算法深度优先算法图论
                        
          图论算法经典题目解析：DFS、BFS与拓扑排序实战图论问题是算法面试中的高频考点，本博客将通过四道LeetCode经典题目（均来自"Top100Liked"题库），深入讲解图论的核心算法思想和实现技巧。涵盖DFS、BFS、拓扑排序和前缀树等知识点，每道题配有Java实现和易错点分析。1.岛屿数量(DFS遍历)问题描述给定一个由'1'(陆地)和'0'(水)组成的二维网格，计算岛屿的数量。岛屿由水平或
          
                    
          • 
                    
        • 【异常】使用 LiteFlow 框架时，提示错误ChainDuplicateException: [chain name duplicate] chainName=categoryChallenge
                        本本本添哥
002-进阶开发能力java
                        
          一、报错内容Causedby:com.yomahub.liteflow.exception.ChainDuplicateException:[chainnameduplicate]chainName=categoryChallengeatcom.yomahub.liteflow.parser.helper.ParserHelper.lambda$null$0(ParserHelper.java:1
          
                    
          • 
                    
        • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
          本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
          
                    
          • 
                    
        • Java 队列
                        tryxr
java开发语言队列
                        
          队列一般用什么哪种结构实现队列的特性数据入队列时一定是从尾部插入吗数据出队列时一定是从头部删除吗队列的基本运算有什么队列支持随机访问吗队列的英文表示什么是队列队列从哪进、从哪出队列的进出顺序队列是用哪种结构实现的Queue和Deque有什么区别Queue接口的方法Queue中的add与offer的区别offer、poll、peek的模拟实现如何利用链表实现队列如何利用顺序表实现队列什么叫做双端队列
          
                    
          • 
                    
        • 第二十二天（数据结构，无头节点的单项链表）
                        肉夹馍不加青椒
c语言数据结构
                        
          线性表：一个线性表里面可以是任意的数据元素，但是同一个线性表里面数据应该是同类型的1存在一个/唯一被称为第一个节点的节点2存在一个/唯一被称为最后一个节点的节点3除了第一个以外，每一个元素都有一个前驱节点4除了最后一个，每一个元素都有一个后继节点满足以上性质，这个表就被称为线性表数组就是一个线性表想实现线性表的保存，我们需要考虑下面的事情1元素要保存2元素与元素之间的序偶关系谁是前面的谁是后面的我
          
                    
          • 
                    
        • JVM 内存分配与回收策略：从对象创建到内存释放的全流程
                        

                        
          在JVM的运行机制中，内存分配与回收策略是连接对象生命周期与垃圾收集器的桥梁。它决定了对象在堆内存中的创建位置、存活过程中的区域迁移，以及最终被回收的时机。合理的内存分配策略能减少GC频率、降低停顿时间，是优化Java应用性能的核心环节。本文将系统解析JVM的内存分配规则、对象晋升机制，以及实战中的内存优化技巧。一、对象优先在Eden区分配：新生代的“临时缓冲区”大多数情况下，Java对象在新生代
          
                    
          • 
                    
        • 代码随想录算法训练营第三十五天
                        

                        
          01背包问题二维题目链接01背包问题二维题解importjava.util.Scanner;publicclassMain{publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);intM=sc.nextInt();intN=sc.nextInt();int[]space=newint[M];int[]value=new
          
                    
          • 
                    
        • Redis + Caffeine 实现高效的两级缓存架构
                        周童學
Java缓存redis架构
                        
          Redis+Caffeine实现高效的两级缓存架构引言在现代高并发系统中，缓存是提升系统性能的关键组件之一。传统的单一缓存方案往往难以同时满足高性能和高可用性的需求。本文将介绍如何结合Redis和Caffeine构建一个高效的两级缓存系统，并通过三个版本的演进展示如何逐步优化代码结构。项目源代码：github地址、gitee地址两级缓存架构概述两级缓存通常由本地缓存（如Caffeine）和分布式缓
          
                    
          • 
                    
        • 微信公众号回调java_处理微信公众号消息回调
                        weixin_39607620
微信公众号回调java
                        
          1、背景在上一节中，咱们知道如何接入微信公众号，可是以后公众号会与咱们进行交互，那么微信公众号如何通知到咱们本身的服务器呢？咱们知道咱们接入的时候提供的url是GET/mp/entry，那么公众号以后产生的事件将会以POST/mp/entry发送到咱们本身的服务器上。html2、代码实现，此处仍是使用weixin-java-mp这个框架实现一、引入weixin-java-mpcom.github.
          
                    
          • 
                    
        • 学C++的五大惊人好处
                        

                        
          为什么要学c++学c++有什么用学习c++的好处有1.中考可以加分2.高考可能直接录取3.就业广且工资高4.在未来30--50年c++一定是一个很受欢迎的职业5.c++成功的例子deepsick等AI智能C++语言兼备编程效率和编译运行效率的语言C++语言是C语言功能增强版,在c语言的基础上添加了面向对象编程和泛型编程的支持既继承了C语言高效，简洁，快速和可移植的传统,又具备类似Java、Go等其
          
                    
          • 
                    
        • 机器学习必备数学与编程指南：从入门到精通
                        a小胡哦
机器学习基础机器学习人工智能
                        
          一、机器学习核心数学基础1.线性代数（神经网络的基础）必须掌握：矩阵运算（乘法、转置、逆）向量空间与线性变换特征值分解与奇异值分解(SVD)为什么重要：神经网络本质就是矩阵运算学习技巧：用NumPy实际操作矩阵运算2.概率与统计（模型评估的关键）核心概念：条件概率与贝叶斯定理概率分布（正态、泊松、伯努利）假设检验与p值应用场景：朴素贝叶斯、A/B测试3.微积分（优化算法的基础）重点掌握：导数与偏导
          
                    
          • 
                    
        • Java8 Stream流的sorted()的排序【正序、倒序、多字段排序】
                        Tony666688888
javawindows开发语言
                        
          针对集合排序，java8可以用Stream流的sorted()进行排序。示例Bean以下我们会使用这个Bean来做示例。publicclassOrder{privateStringweight;privateDoubleprice;privateStringdateStr;//忽略getter、setter、构造方法、toString}字段排序首先是比较器Comparator，形式如下：Compa
          
                    
          • 
                    
        • 从振动信号到精准预警：AI 如何重塑工业设备健康管理？
                        缘华工业智维
人工智能计算机视觉边缘计算信息与通信
                        
          在智能制造浪潮席卷全球的当下，工业生产正经历着从传统模式向智能化、数字化转型的深刻变革。在这场变革中，AI驱动的振动分析技术犹如一颗璀璨新星，成为工业设备可靠运行的“健康卫士”。它通过在设备关键部位部署振动传感器，如同医生为患者听诊般实时采集设备运行时的振动信号，再借助强大的人工智能算法对这些“工业脉搏”进行深度解析，从而实现对工业设备从故障预警到寿命预测的全周期精准守护。一、AI振动分析：设备状
          
                    
          • 
                    
        • 基于DeepSeek的下一代大型游戏开发革命：架构、核心技术与项目管理实践
                        Liudef06小白
特殊专栏人工智能AIGC架构人工智能deepseek
                        
          基于DeepSeek的下一代大型游戏开发革命：架构、核心技术与项目管理实践DeepSeek大模型正重塑游戏开发范式，本文将深入解析如何利用这一革命性技术构建下一代大型游戏，涵盖从架构设计到项目管理的全流程实践。目录DeepSeek游戏引擎核心架构1.1神经符号系统融合架构1.2动态世界生成引擎智能NPC与剧情系统2.1角色人格建模技术2.2动态叙事生成算法大型项目管理体系3.1敏捷-AI混合开发流
          
                    
          • 
                    
        • 量子计算解决气候变化：科学家找到了新方法
                        大力出奇迹985
量子计算
                        
          气候变化已成为全球面临的严峻挑战，传统计算方法在应对与之相关的复杂问题时存在诸多局限。而量子计算作为新兴技术，为解决气候变化难题带来曙光。本文深入剖析科学家利用量子计算应对气候变化的新方法。量子计算凭借独特的量子比特与量子特性，在加速气候模型计算、优化模型参数、预测极端天气事件等方面展现出巨大优势。同时，在可再生能源整合、电网管理、碳捕获等实际应用场景中也发挥着重要作用。尽管目前面临硬件和算法等方
          
                    
          • 
                                
        • Spring4.1新特性——综述
                                    jinnianshilongnian
spring 4.1
                                    
          目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
          
                                
          • 
                                
        • Schema与数据类型优化
                                    annan211
数据结构mysql
                                    
          

目前商城的数据库设计真是一塌糊涂，表堆叠让人不忍直视，无脑的架构师，说了也不听。
在数据库设计之初，就应该仔细揣摩可能会有哪些查询，有没有更复杂的查询，而不是仅仅突出
很表面的业务需求，这样做会让你的数据库性能成倍提高，当然，丑陋的架构师是不会这样去考虑问题的。

选择优化的数据类型
 1 更小的通常更好
   更小的数据类型通常更快，因为他们占用更少的磁盘、内存和cpu缓存，
          
                                
          • 
                                
        • 第一节 HTML概要学习
                                    chenke
htmlWebcss
                                    
          第一节 HTML概要学习 
 
1. 什么是HTML 
 
HTML是英文Hyper Text Mark-up Language(超文本标记语言)的缩写，它规定了自己的语法规则，用来表示比“文本”更丰富的意义，比如图片，表格，链接等。浏览器（IE,FireFox等）软件知道HTML语言的语法，可以用来查看HTML文档。目前互联网上的绝大部分网页都是使用HTML编写的。 
 
打开记事本 输入一下内
          
                                
          • 
                                
        • MyEclipse里部分习惯的更改
                                    Array_06
eclipse
                                    
          继续补充中---------------------- 
 
 
 
1.更改自己合适快捷键windows-->prefences-->java-->editor-->Content Assist--> 
     Activation triggers for java的右侧“.”就可以改变常用的快捷键 
 
选中 Text 
          
                                
          • 
                                
        • 近一个月的面试总结
                                    cugfy
面试
                                    
          本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/46753275 
 
 
前言 
      打算换个工作，近一个月面试了不少的公司，下面将一些面试经验和思考分享给大家。另外校招也快要开始了，为在校的学生提供一些经验供参考，希望都能找到满意的工作。 
          
                                
          • 
                                
        • HTML5一个小迷宫游戏
                                    357029540
html5
                                    
               通过《HTML5游戏开发》摘抄了一个小迷宫游戏，感觉还不错，可以画画，写字，把摘抄的代码放上来分享下，喜欢的同学可以拿来玩玩！ 
 
<html> 
 <head> 
 <title>创建运行迷宫</title> 
 <script type="text/javascript"
          
                                
          • 
                                
        • 10步教你上传githib数据
                                    张亚雄
git
                                    
          官方的教学还有其他博客里教的都是给懂的人说得，对已我们这样对我大菜鸟只能这么来锻炼，下面先不玩什么深奥的，先暂时用着10步干净利索。等玩顺溜了再用其他的方法。 
操作过程（查看本目录下有哪些文件NO.1）ls 
（跳转到子目录NO.2）cd+空格+目录 
（继续NO.3）ls 
（匹配到子目录NO.4）cd+ 目录首写字母+tab键+（首写字母“直到你所用文件根就不再按TAB键了”） 
（查看文件
          
                                
          • 
                                
        • MongoDB常用操作命令大全
                                    adminjun
mongodb操作命令
                                    
          成功启动MongoDB后，再打开一个命令行窗口输入mongo，就可以进行数据库的一些操作。输入help可以看到基本操作命令，只是MongoDB没有创建数据库的命令，但有类似的命令   如：如果你想创建一个“myTest”的数据库，先运行use myTest命令，之后就做一些操作（如：db.createCollection('user')）,这样就可以创建一个名叫“myTest”的数据库。   
一
          
                                
          • 
                                
        • bat调用jar包并传入多个参数
                                    aijuans

                                    
          下面的主程序是通过eclipse写的： 
1.在Main函数接收bat文件传递的参数（String[] args） 
 如：   String ip =args[0];          String user=args[1];       &nbs
          
                                
          • 
                                
        • Java中对类的主动引用和被动引用
                                    ayaoxinchao
java主动引用对类的引用被动引用类初始化
                                    
            
在Java代码中，有些类看上去初始化了，但其实没有。例如定义一定长度某一类型的数组，看上去数组中所有的元素已经被初始化，实际上一个都没有。对于类的初始化，虚拟机规范严格规定了只有对该类进行主动引用时，才会触发。而除此之外的所有引用方式称之为对类的被动引用，不会触发类的初始化。虚拟机规范严格地规定了有且仅有四种情况是对类的主动引用，即必须立即对类进行初始化。四种情况如下：1.遇到ne
          
                                
          • 
                                
        • 导出数据库 提示 outfile disabled
                                    BigBird2012
mysql
                                    
          在windows控制台下，登陆mysql，备份数据库： 
  
mysql>mysqldump -u root -p test test > D:\test.sql 
使用命令 mysqldump 格式如下： mysqldump -u root -p *** DBNAME > E:\\test.sql。 
注意：执行该命令的时候不要进入mysql的控制台再使用，这样会报
          
                                
          • 
                                
        • Javascript 中的 && 和 ||
                                    bijian1013
JavaScript&&||
                                    
                  准备两个对象用于下面的讨论 
var alice = {
    name: "alice",
    toString: function () {
        return this.name;
    }
}
var smith = {
    name: "smith",
 
          
                                
          • 
                                
        • [Zookeeper学习笔记之四]Zookeeper Client Library会话重建
                                    bit1129
zookeeper
                                    
          为了说明问题，先来看个简单的示例代码： 
  
package com.tom.zookeeper.book;

import com.tom.Host;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Wat
          
                                
          • 
                                
        • 【Scala十一】Scala核心五：case模式匹配
                                    bit1129
scala
                                    
          package spark.examples.scala.grammars.caseclasses

object CaseClass_Test00 {

  def simpleMatch(arg: Any) = arg match {
    case v: Int => "This is an Int"
    case v: (Int, String)
          
                                
          • 
                                
        • 运维的一些面试题
                                    yuxianhua
linux
                                    
          1、Linux挂载Winodws共享文件夹 
  
mount -t cifs //1.1.1.254/ok /var/tmp/share/ -o username=administrator,password=yourpass
或
mount -t cifs -o username=xxx,password=xxxx //1.1.1.1/a /win 
  
 
          
                                
          • 
                                
        • Java lang包-Boolean
                                    BrokenDreams
boolean
                                    
                   Boolean类是Java中基本类型boolean的包装类。这个类比较简单，直接看源代码吧。 
 

public final class Boolean implements java.io.Serializable,
                                      
          
                                
          • 
                                
        • 读《研磨设计模式》-代码笔记-命令模式-Command
                                    bylijinnan
java设计模式
                                    
          声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * GOF 在《设计模式》一书中阐述命令模式的意图：“将一个请求封装
          
                                
          • 
                                
        • matlab下GPU编程笔记
                                    cherishLC
matlab
                                    
          不多说，直接上代码 
 
gpuDevice   %   查看系统中的gpu,,其中的DeviceSupported会给出matlab支持的GPU个数。
g=gpuDevice(1);    %会清空 GPU 1中的所有数据,,将GPU1 设为当前GPU
reset(g)  %也可以清空GPU中数据。

a=1;
a=gpuArray(a);    %将a从CPU移到GPU中
onGP
          
                                
          • 
                                
        • SVN安装过程
                                    crabdave
SVN
                                    
          SVN安装过程 
  
subversion-1.6.12 
  
./configure --prefix=/usr/local/subversion --with-apxs=/usr/local/apache2/bin/apxs --with-apr=/usr/local/apr --with-apr-util=/usr/local/apr --with-openssl=/
          
                                
          • 
                                
        • sql　行列转换
                                    daizj
sql行列转换行转列列转行
                                    
          行转列的思想是通过case when 来实现 
列转行的思想是通过union all 来实现 
 
下面具体例子： 
 
假设有张学生成绩表(tb)如下: 
Name Subject Result 
张三 语文　　74 
张三 数学　　83 
张三 物理　　93 
李四 语文　　74 
李四 数学　　84 
李四 物理　　94 
*/ 
/* 
想变成 
姓名   &
          
                                
          • 
                                
        • MySQL--主从配置
                                    dcj3sjt126com
mysql
                                    
             linux下的mysql主从配置：   说明：由于MySQL不同版本之间的(二进制日志)binlog格式可能会不一样，因此最好的搭配组合是Master的MySQL版本和Slave的版本相同或者更低，   Master的版本肯定不能高于Slave版本。（版本向下兼容）   
   mysql1  : 192.168.100.1    //master   mysq
          
                                
          • 
                                
        • 关于yii 数据库添加新字段之后model类的修改
                                    dcj3sjt126com
Model
                                    
          rules: 
array('新字段','safe','on'=>'search') 
1、array('新字段', 'safe')//这个如果是要用户输入的话，要加一下， 
2、array('新字段', 'numerical'),//如果是数字的话 
3、array('新字段', 'length', 'max'=>100),//如果是文本 
1、2、3适当的最少要加一条，新字段才会被
          
                                
          • 
                                
        • sublime text3 中文乱码解决
                                    dyy_gusi
Sublime Text
                                    
          sublime text3中文乱码解决 
原因：缺少转换为UTF-8的插件 
目的：安装ConvertToUTF8插件包 
第一步：安装能自动安装插件的插件，百度“Codecs33”，然后按照步骤可以得到以下一段代码： 
import urllib.request,os,hashlib; h = 'eb2297e1a458f27d836c04bb0cbaf282' + 'd0e7a30980927
          
                                
          • 
                                
        • 概念了解：CGI，FastCGI，PHP-CGI与PHP-FPM
                                    geeksun
PHP
                                    
          CGI 
CGI全称是“公共网关接口”(Common Gateway Interface)，HTTP服务器与你的或其它机器上的程序进行“交谈”的一种工具，其程序须运行在网络服务器上。 
CGI可以用任何一种语言编写，只要这种语言具有标准输入、输出和环境变量。如php,perl,tcl等。 FastCGI 
FastCGI像是一个常驻(long-live)型的CGI，它可以一直执行着，只要激活后，不
          
                                
          • 
                                
        • Git push 报错 "error: failed to push some refs to " 解决
                                    hongtoushizi
git
                                    
          Git push 报错 "error: failed to push some refs to " . 
此问题出现的原因是：由于远程仓库中代码版本与本地不一致冲突导致的。 
由于我在第一次git pull --rebase 代码后，准备push的时候，有别人往线上又提交了代码。所以出现此问题。 
解决方案： 
1： git pull    
2：
          
                                
          • 
                                
        • 第四章 Lua模块开发
                                    jinnianshilongnian
nginxlua
                                    
          在实际开发中，不可能把所有代码写到一个大而全的lua文件中，需要进行分模块开发；而且模块化是高性能Lua应用的关键。使用require第一次导入模块后，所有Nginx 进程全局共享模块的数据和代码，每个Worker进程需要时会得到此模块的一个副本（Copy-On-Write），即模块可以认为是每Worker进程共享而不是每Nginx Server共享；另外注意之前我们使用init_by_lua中初
          
                                
          • 
                                
        • java.lang.reflect.Proxy
                                    liyonghui160com

                                    
            
1.简介 
  
Proxy 提供用于创建动态代理类和实例的静态方法 
（1）动态代理类的属性 
 
 代理类是公共的、最终的，而不是抽象的 
 未指定代理类的非限定名称。但是，以字符串 "$Proxy" 开头的类名空间应该为代理类保留 
 代理类扩展 java.lang.reflect.Proxy  
 代理类会按同一顺序准确地实现其创建时指定的接口
          
                                
          • 
                                
        • Java中getResourceAsStream的用法
                                    pda158
java
                                    
          1.Java中的getResourceAsStream有以下几种： 1. Class.getResourceAsStream(String path) ： path 不以’/'开头时默认是从此类所在的包下取资源，以’/'开头则是从ClassPath根下获取。其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。   　　2. Class.getClassLoader.get
          
                                
          • 
                                
        • spring 包官方下载地址（非maven）
                                    sinnk
spring
                                    
          SPRING官方网站改版后，建议都是通过 Maven和Gradle下载，对不使用Maven和Gradle开发项目的，下载就非常麻烦，下给出Spring Framework jar官方直接下载路径: 
  
 http://repo.springsource.org/libs-release-local/org/springframework/spring/ 
  
s
          
                                
          • 
                                
        • Oracle学习笔记(7) 开发PLSQL子程序和包
                                    vipbooks
oraclesql编程
                                    
              哈哈，清明节放假回去了一下，真是太好了，回家的感觉真好啊！现在又开始出差之旅了，又好久没有来了，今天继续Oracle的学习！ 
     这是第七章的学习笔记，学习完第六章的动态SQL之后，开始要学习子程序和包的使用了……，希望大家能多给俺一些支持啊！ 
    编程时使用的工具是PLSQL
          
                                
          •