ThreadLocal源码认识和理解

╰+哭是因爲堅強的太久メ 2023-02-14 01:38 19阅读 0赞

ThreadLocal是一个非常常用对象，线程的变量副本，每个线程隔离，但对具体如何实现线程隔离，这篇文章试着去了解一下。

### hreadLocal代码演示 ###

public class ThreadLocalDemo {
    
        private static ExecutorService executor = new ThreadPoolExecutor(5, 5,
                10L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>());
    
        private static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    
    
        public static void main(String[] args) {
            for (int i = 0; i < 5; i++) {
                int j = i;
                executor.execute(() -> {
                    String value = "" + j + j + j;
                    threadLocal.set(value);
                    System.out.println(Thread.currentThread().getName() + "设置值：" + value);
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    String getValue = threadLocal.get();
                    System.out.println(Thread.currentThread().getName() + "获取：" + getValue);
    
                });
            }
    
    
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70]

不同线程设置的值和获取的值是同一个，实现线程之间设置的隔离。

### ThreadLocal的数据结构 ###

对于一个ThreadLocal 而言  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 1]  
Thread类有一个类型为ThreadLocal.ThreadLocalMap的成员变量inheritableThreadLocals  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 2]  
如果是多个ThreadLocal的展示情况：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 3]

public class ThreadLocalDemo {
    
    
    
        public static void main(String[] args) throws Exception {
            ThreadLocal<String> local1 = new ThreadLocal<>();
            ThreadLocal<String> local2 = new ThreadLocal<>();
            ThreadLocal<String> local3 = new ThreadLocal<>();
            ThreadLocal<String> local4 = new ThreadLocal<>();
    
            local1.set("local1");
            local2.set("local2");
            local3.set("local3");
            local4.set("local4");
            //得到当前线程
            Thread t = Thread.currentThread();
            Class<? extends Thread> clz = t.getClass();
            //获取当前线程threadLocals class也就是  ThreadLocal.ThreadLocalMap
            Field field = clz.getDeclaredField("threadLocals");
            field.setAccessible(true);
            //得到 ThreadLocal.ThreadLocalMap具体实例
            Object threadLocalMap = field.get(t);
            Class<?> tlmClass = threadLocalMap.getClass();
            //获取到 ThreadLocal.ThreadLocalMap 中的数组 class
            Field tableField = tlmClass.getDeclaredField("table");
            tableField.setAccessible(true);
            //获取到 ThreadLocal.ThreadLocalMap 中的数组 中实例对象
            Object[] arr = (Object[]) tableField.get(threadLocalMap);
            for (Object o : arr) {
                if (o != null) {
                    Class<?> entryClass = o.getClass();
                    Field valueField = entryClass.getDeclaredField("value");
                    // 继承关系  由static class Entry extends WeakReference<ThreadLocal<?>>
                    // 可得 entryClass.getSuperclass() 获取WeakReference 的class
                    //继承关系 public class WeakReference<T> extends Reference<T>
                    //可得 entryClass.getSuperclass().getSuperclass() 得到 Reference的继承关系
                    //referent 是 Reference 的成员变量，也是threadLocal
                    Field referenceField = entryClass.getSuperclass().getSuperclass().getDeclaredField("referent");
                    valueField.setAccessible(true);
                    referenceField.setAccessible(true);
                    System.out.println(String.format("key:%s,值:%s", referenceField.get(o), valueField.get(o)));
                }
            }
    
    
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 4]  
从图片和代码中可以同一个线程的不同ThreadLocal和值放到同一个线程中成员变量threadLocals中

上面的例子虽然定义ThreadLocal，可能会让人联想到数据都是存在ThreadLocal这个类中，  
但实际上Thread类有一个类型为ThreadLocal.ThreadLocalMap的成员变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。

ThreadLocal.ThreadLocalMap 将threadLocal 作为key进行存储，value为我们设置的值。对于同一个ThreadLocal来说，不同线程将值存储到不同线程内部的实例变量中，就对于单个threadLocal 就不存在线程安全的问题。

### ThreadLocal的set 方法 ###

// threadLocal 的get方法
     public void set(T value) {
            Thread t = Thread.currentThread();
            //ThreadLocalMap  是取至thread的成员变量
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
            //从之前图片上Thread 中threadLocals的成员变量，和这可以看出中ThreadLocalMap  是懒加载
                createMap(t, value);
        }
    
    // threadLocal  中的getMap方法可以看出，ThreadLocalMap  是取至thread的成员变量
    ThreadLocalMap getMap(Thread t) {
            return t.threadLocals;
        }
    
    //这个是ThreadLocalMap 中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;
                //算出ThreadLocalMap  中数组的下标
                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) {
                    //清空槽位上key为null的值
                        replaceStaleEntry(key, value, i);
                        return;
                    }
                }
    
                tab[i] = new Entry(key, value);
                int sz = ++size;
                   //调用cleanSomeSlots()做一次启发式清理工作，清理散列数组中Entry的key过期的数据,
                   //如果无数据清理，且数据量超过超过了阈值(数组长度的2/3)，进行rehash()操作
                if (!cleanSomeSlots(i, sz) && sz >= threshold)
             //扩容
                    rehash();
            }
    // nextIndex一直向后，直到entry不为空
    private static int nextIndex(int i, int len) {
                return ((i + 1 < len) ? i + 1 : 0);
            }
    
    //
     private void rehash() {
     			//清理数据
                expungeStaleEntries();
    
                // Use lower threshold for doubling to avoid hysteresis
                //清理完如果容量超过3/4则扩容
                if (size >= threshold - threshold / 4)
                    resize();
            }
            //从传入节点清理数据，如果有数据清理则为true ,无数据清理则为false
     private boolean cleanSomeSlots(int i, int n) {
                boolean removed = false;
                Entry[] tab = table;
                int len = tab.length;
                do {
                    i = nextIndex(i, len);
                    Entry e = tab[i];
                    if (e != null && e.get() == null) {
                        n = len;
                        removed = true;
                        i = expungeStaleEntry(i);
                    }
                } while ( (n >>>= 1) != 0);
                return removed;
            }

### ThreadLocal的get方法 ###

public T get() {
            Thread t = Thread.currentThread();
            //和set方法一样，去Thread 获取 thread的成员变量
            ThreadLocalMap map = getMap(t);
            if (map != null) {
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            return setInitialValue();
        }
        //通过threadLocal 获取节点
      private Entry getEntry(ThreadLocal<?> key) {
                int i = key.threadLocalHashCode & (table.length - 1);
                Entry e = table[i];
                //如果直接是该threadLocal 直接返回
                if (e != null && e.get() == key)
                    return e;
                else
                //1、该节点上面值为null  2、该节点和其他节点hash冲突了
                    return getEntryAfterMiss(key, i, e);
            }
    
    
     private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
                Entry[] tab = table;
                int len = tab.length;
    			//e 如果直接为null 不进入while循环，直接返回 null
                while (e != null) {
                    ThreadLocal<?> k = e.get();
                    //遇到该hash的值，直接返回
                    if (k == key)
                        return e;
                        //如果过期，清理过期值
                    if (k == null)
                        expungeStaleEntry(i);
                    else
                        i = nextIndex(i, len);
                    e = tab[i];
                }
                return null;
            }

### ThreadLocal中ThreadLocalMap 的 Entry extends WeakReference ###

//ThreadLocalMap 的 Entry extends WeakReference<ThreadLocal<?>> 中key的值是弱引用
       static class Entry extends WeakReference<ThreadLocal<?>> {
                /** The value associated with this ThreadLocal. */
                Object value;
    
                Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
            }

但value是set的值属于强引用，当threadlocal 为gc回收之后，value一直留在ThreadLocalMap 之中。造成内存泄漏，从源码上分析，get,set，扩容 的时候都有检查是否ThreadLocalMap 中是否key过期，如果过期将value设置为空。我们在使用当中，如果该value中值不再使用可以使用remove方法置value置空。

public void remove() {
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
                 m.remove(this);
         }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200530144540666.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200530145446307.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200530151946763.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200530150904386.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200530153514721.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhamluZ19mZWl5dWU=,size_16,color_FFFFFF,t_70