/** * A Thread implementation that records the time at which it was created. * */ public class TaskThread extends Thread {private final long creationTime; public TaskThread(ThreadGroup group, Runnable target, String name) { super(group, new WrappingRunnable(target), name); this.creationTime = System.currentTimeMillis(); }/** * Wraps a {@link Runnable} to swallow any {@link StopPooledThreadException} * instead of letting it go and potentially trigger a break in a debugger. */ private static class WrappingRunnable implements Runnable { private Runnable wrappedRunnable; WrappingRunnable(Runnable wrappedRunnable) { this.wrappedRunnable = wrappedRunnable; } @Override public void run() { try { wrappedRunnable.run(); } catch(StopPooledThreadException exc) { //expected : we just swallow the exception to avoid disturbing //debuggers like eclipse's log.debug("Thread exiting on purpose", exc); } }}}

/** * Allows the server developer to specify the acceptCount (backlog) that * should be used for server sockets. By default, this value * is 100. */ private int acceptCount = 100; private int maxConnections = 10000;

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 simpleDateFormatThreadLocal = new ThreadLocal() { @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 = https://www.it610.com/article/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> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal k, Object v) { super(k); value = https://www.it610.com/article/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 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 list = new LinkedList<>(); for (int i = 0; i < count; i++) { ThreadLocalDemo demo = new ThreadLocalDemo(); demo.setValue("demo-" + i); list.add(demo); } System.out.println(); } }