如何判断Java ThreadLocal已被移除？嵌套拦截场景优化方案

现有拦截方法执行流程如下：

interceptorMethod () {
    try {
        ContextHolder.init();
        doSomething();
    } finally {
        ContextHolder.clear();
    }
}

ContextHolder的实现：

class ContextHolder {
    ThreadLocal<Integer> data1 = new ThreadLocal<>();
    ThreadLocal<Integer> data2 = new ThreadLocal<>();
    
    void init(int d1, int d2) {
       data1.set(d1);
       data2.set(d2);
    }
    
    void clear() {
       data1.remove();
       data2.remove();
    }
    
    // data1和data2的getter、setter方法
}

当doSomething被重复拦截（即interceptorMethod执行两次）时，会出现init和clear各被调用两次的情况，连续调用clear会引发问题。

为此考虑新增一个ThreadLocal<Integer>计数器，修改后的ContextHolder逻辑如下：

class ContextHolder {
    ThreadLocal<Integer> data1 = new ThreadLocal<>();
    ThreadLocal<Integer> data2 = new ThreadLocal<>();
    ThreadLocal<Integer> counter = new ThreadLocal<>();
    
    void init(int d1, int d2) {
       // 此处如何判断counter已被移除？
       if (isRemoved(counter)) {
           counter.set(0);
       } else {
           counter.set(counter.get() + 1);
       }
       data1.set(d1);
       data2.set(d2);
    }
    
    void clear() {
       if (0 == minusCounter(counter)) {
           data1.remove();
           data2.remove();
           counter.remove();
       } 
    }
}

请问如何检测ThreadLocal是否已被移除？或者有没有不使用计数器的更优实现方案？

一、检测ThreadLocal是否被移除的方法 #

ThreadLocal没有直接提供检测移除状态的API，但可以通过get()方法的返回值判断：如果调用counter.get()返回null，说明该ThreadLocal在当前线程中从未设置过值，或者已经被remove()清除。

基于此修改init和辅助方法：

void init(int d1, int d2) {
    Integer count = counter.get();
    if (count == null) {
        counter.set(0);
    } else {
        counter.set(count + 1);
    }
    data1.set(d1);
    data2.set(d2);
}

private int minusCounter(ThreadLocal<Integer> counter) {
    Integer count = counter.get();
    if (count == null) {
        return 0;
    }
    int newCount = count - 1;
    counter.set(newCount);
    return newCount;
}

这样就能正确维护计数器的状态，只有当计数器归0时，才会清除上下文数据和计数器本身。

二、无计数器的更优实现方案 #

可以把所有上下文数据和引用计数封装到同一个对象中，用单个ThreadLocal存储该对象，逻辑更内聚且减少ThreadLocal实例数量：

class ContextHolder {
    private static class Context {
        int data1;
        int data2;
        int refCount;
        
        Context(int d1, int d2) {
            this.data1 = d1;
            this.data2 = d2;
            this.refCount = 1;
        }
    }
    
    private static final ThreadLocal<Context> contextThreadLocal = new ThreadLocal<>();
    
    public static void init(int d1, int d2) {
        Context ctx = contextThreadLocal.get();
        if (ctx == null) {
            contextThreadLocal.set(new Context(d1, d2));
        } else {
            ctx.data1 = d1;
            ctx.data2 = d2;
            ctx.refCount++;
        }
    }
    
    public static void clear() {
        Context ctx = contextThreadLocal.get();
        if (ctx == null) {
            return;
        }
        ctx.refCount--;
        if (ctx.refCount == 0) {
            contextThreadLocal.remove();
        }
    }
    
    // 示例getter方法
    public static int getData1() {
        Context ctx = contextThreadLocal.get();
        return ctx != null ? ctx.data1 : 0; // 根据业务需求处理null场景
    }
}

这种方案的优势：

• 用单个ThreadLocal管理所有上下文数据，降低内存管理复杂度
• 引用计数和上下文数据绑定，逻辑更清晰
• 同样能处理嵌套/重复拦截场景，只有当引用计数归0时才真正清除ThreadLocal

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