ThreadLocal 与线程复用：请求结束后清理身份上下文

import java.util.*;
import java.util.concurrent.*;

public class Main {
    static final ThreadLocal<Deque<Scope>> STACK=new ThreadLocal<>();
    static final class Scope implements AutoCloseable {
        final Thread owner=Thread.currentThread();
        final Map<String,String> values;
        boolean closed;
        Scope(Map<String,String> values) { this.values=Map.copyOf(values); }
        public void close() {
            if(Thread.currentThread()!=owner) throw new IllegalStateException("wrong thread");
            if(closed) return;
            Deque<Scope> stack=STACK.get();
            if(stack==null || stack.peek()!=this) throw new IllegalStateException("wrong close order");
            stack.pop(); closed=true; // 验证通过后才修改状态，错误关闭保持原栈。
            if(stack.isEmpty()) STACK.remove(); // 最外层结束主动断开线程上的引用。
        }
    }
    static Scope open(Map<String,String> values) {
        Scope scope=new Scope(values); // 先验证和复制，失败时不修改线程上下文。
        Deque<Scope> stack=STACK.get();
        if(stack==null) { stack=new ArrayDeque<>(); STACK.set(stack); }
        stack.push(scope); return scope;
    }
    static Map<String,String> current() {
        Deque<Scope> stack=STACK.get();
        if(stack==null) { STACK.remove(); return Map.of(); }
        return stack.peek().values;
    }
    static void check(boolean ok) { if(!ok) throw new AssertionError(); }
    public static void main(String[] args) throws Exception {
        check(current().isEmpty());
        Scope a=open(Map.of("trace","A")), b=open(Map.of("trace","B"));
        check(current().get("trace").equals("B"));
        try { a.close(); throw new AssertionError(); } catch(IllegalStateException expected) { }
        check(current().get("trace").equals("B"));
        b.close(); b.close(); check(current().get("trace").equals("A"));
        Map<String,String> captured=current();
        ExecutorService executor=Executors.newSingleThreadExecutor();
        try {
            check(executor.submit(() -> {
                check(current().isEmpty());
                try(Scope ignored=open(captured)) { return current().get("trace").equals("A"); }
            }).get(5,TimeUnit.SECONDS));
            check(executor.submit(() -> current().isEmpty()).get(5,TimeUnit.SECONDS));
            check(executor.submit(() -> {
                try { a.close(); return false; } catch(IllegalStateException expected) { return true; }
            }).get(5,TimeUnit.SECONDS));
        } finally { executor.shutdownNow(); a.close(); }
        try(Scope ignored=open(Map.of("trace","C"))) { throw new IllegalArgumentException(); }
        catch(IllegalArgumentException expected) { check(current().isEmpty()); }
        System.out.println("PASS 8");
    }
}