《Java 并发编程·性能诊断与事故》15.2 Code Review 清单

[阻断] BorrowTask.java:37 / R-11
问题：CTX.set(reqId) 在池线程里执行，任务结束没有 remove；worker 复用时，
      下一个请求会读到上一个请求的 ID。
证据：最小复现（单线程池、两个任务），本机 Temurin 25.0.5+8 原样输出：
      leak  task-1 ctx=req-A
      leak  task-2 ctx=req-A     ← 第二个任务读到了第一个请求的值
      fixed task-2 ctx=null
改法：set 与 remove 必须在同一个线程，remove 放在任务体的 finally；
      若改用 ScopedValue，注意它不跨 Thread.start() 继承。
代价：多一次 remove；跨线程传递仍需显式参数或结构化并发作用域。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public final class ContextLeakProbe {

    private static final ThreadLocal<String> CTX = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        run("leak");
        run("fixed");
    }

    static void run(String mode) throws Exception {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4),
                r -> Thread.ofPlatform().name("ctx-worker").unstarted(r));
        try {
            pool.submit(() -> {
                CTX.set("req-A");
                System.out.println(mode + " task-1 ctx=" + CTX.get());
                if (mode.equals("fixed")) {
                    CTX.remove();
                }
            }).get();
            pool.submit(() -> System.out.println(mode + " task-2 ctx=" + CTX.get())).get();
        } finally {
            pool.shutdown();
            pool.awaitTermination(1, TimeUnit.SECONDS);
        }
    }
}

leak task-1 ctx=req-A
leak task-2 ctx=req-A
fixed task-1 ctx=req-A
fixed task-2 ctx=null

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

/** 评审闸门：把「级别 + 证据 + 验证方式 + 豁免」变成可判定的合并结论。 */
public final class ReviewGate {

    public enum Level { BLOCK, REQUIRE, SUGGEST }

    public record Finding(String id, Level level, String question,
                          boolean hasEvidence, boolean hasVerification, boolean waiver) {}

    public record Verdict(String decision, List<String> reasons) {}

    public static Verdict decide(List<Finding> findings) {
        int block = 0;
        int require = 0;
        int unverifiable = 0;
        int waived = 0;
        for (Finding f : findings) {
            if (f.level() == Level.BLOCK) {
                block++;
                if (f.waiver()) {
                    waived++;
                }
            } else if (f.level() == Level.REQUIRE) {
                require++;
            }
            if (f.level() != Level.SUGGEST && !f.hasVerification()) {
                unverifiable++;
            }
        }
        List<String> reasons = new ArrayList<>();
        if (block > waived) {
            reasons.add("阻断项 " + block + " 条，其中仅 " + waived + " 条有豁免论证");
        }
        if (unverifiable > 0) {
            reasons.add("有 " + unverifiable + " 条要求未给出验证方式，等于无法验收");
        }
        if (waived > 0) {
            reasons.add(waived + " 条阻断项以豁免放行，必须二人复核并登记到期时间");
        }
        if (require > 2) {
            reasons.add("要求改 " + require + " 条，超过 2 条说明改动面过大，建议拆 PR");
        } else if (require > 0) {
            reasons.add("要求改 " + require + " 条，改完复核");
        }
        String decision;
        if (block > waived || unverifiable > 0) {
            decision = "BLOCK";
        } else if (waived > 0 || require > 0) {
            decision = "REQUIRE";
        } else {
            decision = "APPROVE";
        }
        return new Verdict(decision, reasons);
    }

    public static void main(String[] args) {
        record Round(String name, List<Finding> findings) {}

        List<Round> rounds = List.of(
                new Round("round-1", List.of(
                        new Finding("R-03", Level.BLOCK, "synchronized 内调用下游 RPC", true, false, false),
                        new Finding("R-07", Level.BLOCK, "池的关闭顺序未定义", false, false, false),
                        new Finding("R-11", Level.REQUIRE, "新增 32 个线程的依据", true, true, false),
                        new Finding("R-15", Level.REQUIRE, "中断语义在异步链路上丢失", true, true, false),
                        new Finding("R-18", Level.SUGGEST, "线程名缺少业务前缀", true, true, false))),
                new Round("round-2", List.of(
                        new Finding("R-11", Level.REQUIRE, "新增 32 个线程的依据", true, true, false),
                        new Finding("R-15", Level.REQUIRE, "中断语义在异步链路上丢失", true, true, false),
                        new Finding("R-18", Level.SUGGEST, "线程名缺少业务前缀", true, true, false))),
                new Round("round-3", List.of(
                        new Finding("R-18", Level.SUGGEST, "线程名缺少业务前缀", true, true, false))));

        for (Round round : rounds) {
            Verdict verdict = decide(round.findings());
            System.out.printf(Locale.ROOT, "%s decision=%s%n", round.name(), verdict.decision());
            for (String reason : verdict.reasons()) {
                System.out.println("  reason: " + reason);
            }
        }
    }
}

round-1 decision=BLOCK
  reason: 阻断项 2 条，其中仅 0 条有豁免论证
  reason: 有 2 条要求未给出验证方式，等于无法验收
  reason: 要求改 2 条，改完复核
round-2 decision=REQUIRE
  reason: 要求改 2 条，改完复核
round-3 decision=APPROVE