public void destroy() {
        try {
            poolExecutor.shutdown();
            if (!poolExecutor.awaitTermination(AWAIT_TIMEOUT, TimeUnit.SECONDS)) {
                poolExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            // 如果当前线程被中断，重新取消所有任务
            pool.shutdownNow();
            // 保持中断状态
            Thread.currentThread().interrupt();
        }
    }

/**
* 在主线程中，开启鹰眼异步模式，并将ctx传递给多线程任务
**/
// 防止鹰眼链路丢失，需要传递
RpcContext_inner ctx = EagleEye.getRpcContext();
// 开启异步模式
ctx.setAsyncMode(true);
/**
* 在线程池任务线程中，设置鹰眼rpc环境
**/
private void runTask() {
    try {
        EagleEye.setRpcContext(ctx);
        // do something...
    } catch (Exception e) {
        log.error("requestError, params: {}", this.params, e);
    } finally {
        // 判断当前任务是否是主线程在运行，当Rejected策略为CallerRunsPolicy的时候，核对当前线程
        if (mainThread != Thread.currentThread()) {
            EagleEye.clearRpcContext();
        }
    }
}

/**
* 使用 ThreadLocal 定义一个全局的 SimpleDateFormat
*/
private static ThreadLocal<SimpleDateFormat> simpleDateFormatThreadLocal = new
ThreadLocal<SimpleDateFormat>() {
@Override
protected SimpleDateFormat initialValue() {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
}
};
// 用法
String dateString = simpleDateFormatThreadLocal.get().format(calendar.getTime());

/**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
public T get() {
    // 1. 获取当前线程
    Thread t = Thread.currentThread();
    // 2. 获取当前线程内部的ThreadLocalMap变量t.threadLocals;
    ThreadLocalMap map = getMap(t);
    // 3. 判断map是否为null
    if (map != null) {
        // 4. 使用当前threadLocal变量获取entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 5. 判断entry是否为null
        if (e != null) {
            // 6.返回Entry.value
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 7. 如果map/entry为null设置初始值
    return setInitialValue();
}
 /**
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
private T setInitialValue() {
    // 1. 初始化value，如果重写就用重写后的value，默认null
    T value = initialValue();
    // 2. 获取当前线程
    Thread t = Thread.currentThread();
    // 3. 获取当前线程内部的ThreadLocalMap变量
    ThreadLocalMap map = getMap(t);
    if (map != null)
        // 4. 不为null就set, key: threadLocal, value: value
        map.set(this, value);
    else
        // 5. map若为null则创建ThreadLocalMap对象
        createMap(t, value);
    return value;
}
/**
 * Create the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param t the current thread
 * @param firstValue value for the initial entry of the map
 */
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}
/**
 * Construct a new map initially containing (firstKey, firstValue).
 * ThreadLocalMaps are constructed lazily, so we only create
 * one when we have at least one entry to put in it.
 */
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    // 1. 初始化entry数组，size: 16
    table = new Entry[INITIAL_CAPACITY];
    // 2. 计算value的index
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    // 3. 在对应index位置赋值
    table[i] = new Entry(firstKey, firstValue);
    // 4. entry size
    size = 1;
    // 5. 设置threshold: threshold = len * 2 / 3;
    setThreshold(INITIAL_CAPACITY);
}
/**
 * Set the resize threshold to maintain at worst a 2/3 load factor.
 */
private void setThreshold(int len) {
    threshold = len * 2 / 3;
}

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        // 1. 获取当前线程
        Thread t = Thread.currentThread();
        // 2. 获取当前线程内部的ThreadLocalMap变量
        ThreadLocalMap map = getMap(t);
        if (map != null)
            // 3. 设置value
            map.set(this, value);
        else
            // 4. 若map为null则创建ThreadLocalMap
            createMap(t, value);
    }

static class ThreadLocalMap {
        /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
    // ...
}

EagleEyeHttpRequest eagleEyeHttpRequest = this.convertHttpRequest(httpRequest);
// 1. 初始化，将traceId、rpcId等数据存储到鹰眼的ThreadLocal变量中
EagleEyeRequestTracer.startTrace(eagleEyeHttpRequest, false);
try {
    chain.doFilter(httpRequest, httpResponse);
} finally {
    // 2. 清理ThreadLocal变量值
    EagleEyeRequestTracer.endTrace(this.convertHttpResponse(httpResponse));
}

public class ThreadLocalTest {
    public static class ThreadLocalDemo {
        private ThreadLocal<String> threadLocalHolder = new ThreadLocal();
        public void setValue(String value) {
            threadLocalHolder.set(value);
        }
        public String getValue() {
            return threadLocalHolder.get();
        }
    }
    public static void main(String[] args) {
        int count = 3;
        List<ThreadLocalDemo> list = new LinkedList<>();
        for (int i = 0; i < count; i++) {
            ThreadLocalDemo demo = new ThreadLocalDemo();
            demo.setValue("demo-" + i);
            list.add(demo);
        }
        System.out.println();
    }
}

// 反例，实际上使用了共享对象obj而并未隔离，
private static ThreadLocal<Obj> threadLocal = ThreadLocal.withIntitial(() -> obj);