ThreadLocal vs InheritableThreadLocal

爱被打了一巴掌 2023-10-03 16:03 6阅读 0赞

ThreadLocal/InheritableThreadLocal线程本地变量容器，是一种以空间换时间的解决方案（存在内存泄漏隐患），InheritableThreadLocal 父子线程本地变量表，父线程中创建的变量可以遗传到子线程中使用。

## 1.demo ##

public class MyThreadLocalTest {
    
        public static void main(String[] args) throws InterruptedException {
            // ThreadLocal 当前线程内本地变量表
            MyCounter.set(1);
            System.out.println("MyCounter主线程计数=" + MyCounter.get());
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("MyCounter子线程计数=" + MyCounter.get());
                    MyCounter.set(2);
                    System.out.println("MyCounter子线程计数=" + MyCounter.get());
                }
            }).start();
            Thread.sleep(100);
            System.out.println("MyCounter主线程计数=" + MyCounter.get());
    
            Thread.sleep(100);
            System.out.println();
    
            // InheritableThreadLocal 父子线程内本地变量表
            MyCounter2.set(1);
            System.out.println("MyCounter2主线程计数=" + MyCounter2.get());
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("MyCounter2子线程计数=" + MyCounter2.get());
                    MyCounter2.set(2);
                    System.out.println("MyCounter2子线程计数=" + MyCounter2.get());
                }
            }).start();
            Thread.sleep(100);
            System.out.println("MyCounter2主线程计数=" + MyCounter2.get());
        }
    
    
    }
    
    class MyCounter {
        private static final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    
        public static Integer get() {
            return threadLocal.get();
        }
    
        public static void set(Integer integer) {
           threadLocal.set(integer);
        }
    }
    
    class MyCounter2 {
        private static final InheritableThreadLocal<Integer> threadLocal = new InheritableThreadLocal<>();
    
        public static Integer get() {
            return threadLocal.get();
        }
    
        public static void set(Integer integer) {
            threadLocal.set(integer);
        }
    }

## 2.源码分析 ##

### 2.1 Thread 初始化源码 ###

在初始化时将 parent.inheritableThreadLocals 赋值给了子线程。

private void init(ThreadGroup g, Runnable target, String name,
                          long stackSize, AccessControlContext acc) {
            if (name == null) {
                throw new NullPointerException("name cannot be null");
            }
    
            this.name = name.toCharArray();
    
            Thread parent = currentThread();
            SecurityManager security = System.getSecurityManager();
            if (g == null) {
                /* Determine if it's an applet or not */
    
                /* If there is a security manager, ask the security manager
                   what to do. */
                if (security != null) {
                    g = security.getThreadGroup();
                }
    
                /* If the security doesn't have a strong opinion of the matter
                   use the parent thread group. */
                if (g == null) {
                    g = parent.getThreadGroup();
                }
            }
    
            /* checkAccess regardless of whether or not threadgroup is
               explicitly passed in. */
            g.checkAccess();
    
            /*
             * Do we have the required permissions?
             */
            if (security != null) {
                if (isCCLOverridden(getClass())) {
                    security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
                }
            }
    
            g.addUnstarted();
    
            this.group = g;
            this.daemon = parent.isDaemon();
            this.priority = parent.getPriority();
            if (security == null || isCCLOverridden(parent.getClass()))
                this.contextClassLoader = parent.getContextClassLoader();
            else
                this.contextClassLoader = parent.contextClassLoader;
            this.inheritedAccessControlContext =
                    acc != null ? acc : AccessController.getContext();
            this.target = target;
            setPriority(priority);
            if (parent.inheritableThreadLocals != null)
                this.inheritableThreadLocals =
                    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
            /* Stash the specified stack size in case the VM cares */
            this.stackSize = stackSize;
    
            /* Set thread ID */
            tid = nextThreadID();
        }

### 2.2 Thread 线程变量存储容器 ###

/* ThreadLocal values pertaining to this thread. This map is maintained
         * by the ThreadLocal class. */
        ThreadLocal.ThreadLocalMap threadLocals = null;
    
        /*
         * InheritableThreadLocal values pertaining to this thread. This map is
         * maintained by the InheritableThreadLocal class.
         */
        ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

### 2.3 ThreadLocalMap 核心代码 ###

/**
             * The initial capacity -- MUST be a power of two.
             */
            private static final int INITIAL_CAPACITY = 16;
    
            /**
             * The table, resized as necessary.
             * table.length MUST always be a power of two.
             */
            private Entry[] table;
    
            
    
            /**
             * Get the entry associated with key.  This method
             * itself handles only the fast path: a direct hit of existing
             * key. It otherwise relays to getEntryAfterMiss.  This is
             * designed to maximize performance for direct hits, in part
             * by making this method readily inlinable.
             *
             * @param  key the thread local object
             * @return the entry associated with key, or null if no such
             */
            private Entry getEntry(ThreadLocal<?> key) {
                int i = key.threadLocalHashCode & (table.length - 1);
                Entry e = table[i];
                if (e != null && e.get() == key)
                    return e;
                else
                    return getEntryAfterMiss(key, i, e);
            }
    
    
            /**
             * Set the value associated with key.
             *
             * @param key the thread local object
             * @param value the value to be set
             */
            private void set(ThreadLocal<?> key, Object value) {
    
                // We don't use a fast path as with get() because it is at
                // least as common to use set() to create new entries as
                // it is to replace existing ones, in which case, a fast
                // path would fail more often than not.
    
                Entry[] tab = table;
                int len = tab.length;
                int i = key.threadLocalHashCode & (len-1);
    
                for (Entry e = tab[i];
                     e != null;
                     e = tab[i = nextIndex(i, len)]) {
                    ThreadLocal<?> k = e.get();
    
                    if (k == key) {
                        e.value = value;
                        return;
                    }
    
                    if (k == null) {
                        replaceStaleEntry(key, value, i);
                        return;
                    }
                }
    
                tab[i] = new Entry(key, value);
                int sz = ++size;
                if (!cleanSomeSlots(i, sz) && sz >= threshold)
                    rehash();
            }