[java并发编程] ThreadLocal详解

爱被打了一巴掌 2023-07-01 06:26 87阅读 0赞

前言：  
我们在多线程编程的时候，会使用到共享变量，为了保证多个线程对共享变量的安全访问，通常会使用synchronizedl来保证同一时刻只有一个线程对共享变量进行操作。在这种情况下，就可以将类变量放到ThreadLocal类型的对象中，使变量在每个线程中都有独立拷贝，不会出现一个线程读取变量而被另一个线程修改的现象。

### ThreadLocal ###

ThreadLocal是JDK底层提供的一个解决多线程并发问题的工具类，他为每个线程提供了一个本地的副本变量机制，实现了和其他线程隔离，并且这种变量只在本线程的生命周期内起作用，可以减少同一个线程内多个方法之间的公共变量传递的复杂度。

### ThreadLocal应用 ###

ThreadLocal主要解决两类问题：

*  并发问题：使用ThreadLocal代替synchronized来保证线程安全，同步机制采用空间换时间仅先提供一份变量，各个线程轮流访问，后者每个线程都持有一份变量，访问时互不影响。
 *  数据存储问题：ThreadLocal为变量在每个线程种创建了一个副本，所以每个线程都可以访问自己内部的副本变量。

### ThreadLocal的实现原理 ###

ThreadLocal主要分为2个部分：第一部分是它的一些成员属性，这部分主要和计算哈希值相关的。另一部分是它对外提供的几个API,这些方法可以操作它自己内部非常重要的内部类。

早期的 ThreadLocal 是每个 ThreadLocal 类都会去创建一个 Map，然后以线程 id作为 key，要存储的局部变量作为 value，这样就可以达到线程隔离的效果。但是这样的话,这个存储数量是 Thread 的数量决定,当线程销毁之后还要去维护 Map中的那份 k-v 让它也随之销毁。后来的版本是这么设计的：每个线程都维护一个 ThreadlocalMap 哈希表(类似HashMap),这个哈希表的 key 是 ThreadLocal 对象本身，value 是要存储的局部副本值，这样的话存储数量是 ThreadLocal 的数量决定的。当 Thread 销毁之后,ThreadLocalMap 也会被随之销毁,减少内存占用。  
而ThreadLocalMap的实现原理跟HashMap 差不多，内部有一个 Entry 数组，一个 Entry通常至少包括key,value , 特殊的是这个Entry继承了 WeakReference 也就是说它是弱引用的所以可能会有 内存泄露 的情况。这个后面再说。ThreadLocal 负责管理 ThreadLocalMap ，包括插入，删除 等等.另一方面来说 ThreadLocal 基本上就相当于 门面设计模式中的一个Facade类。key就是 ThreadLocal 对象自己，同时，很重要的一点:就ThreadLocal把 Map 存储在当前线程对象里面  
我们来看看部分ThreadLocal源代码：

public class ThreadLocal<T> { 
        /** * 自定义哈希码(ThreadLocalMaps的),降低哈希冲突 */
        private final int threadLocalHashCode = nextHashCode();
    
        /** * 生成下一个哈希码的hashCode,操作是原子的,从0开始 */
        private static AtomicInteger nextHashCode =
            new AtomicInteger();
    
        /** * 连续分配的两个ThreadLocal实例的threadLocalHashCode值的增量 */
        private static final int HASH_INCREMENT = 0x61c88647;
    
        /** * 返回下一个哈希码的hashCode,此方法是一个原子类不停地去加上斐波那契散列数,使得哈希值分布均匀 */
        private static int nextHashCode() { 
            return nextHashCode.getAndAdd(HASH_INCREMENT);
        }
    
    }

再来看一看ThreadLocal的方法：

/** * 此方法第一次调用发生在当线程通过 {@link #get} 方法访问此线程的ThreadLocal值时 * 除非线程先调用了 {@link #set}，在这种情况下,{@code initialValue} 方法才不会被这个线程调用 * 通常情况下,每个线程最多调用1次这个方法,但是也可能再次调用,比如 {@link #remove} 被调用后,调用get * 这个方法仅仅简单返回null{@code null}; 如果程序想要它返回除了null之外的初始值,必须继承重写此方法, * 通常使用匿名内部类的方式实现 * @return 返回当前ThreadLocal的初始值 null */
        protected T initialValue() { 
            return null;
        }
    
        /** * 返回当前线程中保存ThreadLocal的值 * 如果当前线程没有此ThreadLocal则通过 {@link #initialValue}方法进行初始化值 * @return */
        public T get() { 
            // 获取当前线程对象
            Thread t = Thread.currentThread();
            // 获取此线程对象中维护的`ThreadLocalMap`对象
            ThreadLocalMap map = getMap(t);
            // 如果Map存在
            if (map != null) { 
                // 以当前ThreadLocal实例对象为key获取对应的存储实体e
                ThreadLocalMap.Entry e = map.getEntry(this);
                // 找到对应的存储实体e
                if (e != null) { 
                    @SuppressWarnings("unchecked")
                    // 获取e对应的value值,也就是我们想要的当前线程对应此ThreadLocal的值
                    T result = (T)e.value;
                    return result;
                }
            }
            // 如果map不存在,证明此线程没有维护此ThreadlocalMap对象,进行一波初始化操作
            return setInitialValue();
        }
    
        /** * set的变样实现,用于初始化值initialValue * 用来代替防止用户重写set而无法初始化 * @return 返回初始化后的值 */
        private T setInitialValue() { 
            T value = initialValue();
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            // 如果此map村咋洗,调用map,set设置此实体entry
            if (map != null)
                map.set(this, value);
            else
             // map不存在时,调用此方法进行ThreadLocalMap对象初始化并将此entry作为第一个值放进去
                createMap(t, value);
             // 返回设置的value值s
            return value;
        }
    
        /** * 设置此线程对应的ThreadLocal的值,大多数子类不需要重写此方法, * 只需要依赖{@link #initialValue} 方法代替设置当前线程对应的ThreadLocal值 * @param 将要保存在当前线程对应的ThreadLocal值 * 1. 获取当前线程`Thread`对象,进而获取此线程对象中维护的`ThreadLocalMap`对象 *2. 判断当前的`ThreadLocalMap`是否存在,如果存在就直接调用map.set设置entry,如果不存在就调用`createMap`进行`ThreadLocalMap`对象的初始化,并将此实体`entry`作为第一个值存放到`ThreadLocalMap`中。 */
        public void set(T value) { 
            Thread t = Thread.currentThread();
            // 获取当前线程的ThreadLocalMap实例
            ThreadLocalMap map = getMap(t);
            // 存在就设置此entry
            if (map != null)
                map.set(this, value);
            else
            // 不存在就进行对象初始化并设置entry作为第一个值存入ThreadLocalMap中
                createMap(t, value);
        }
    
        /** * 删除当前线程中保存ThreadLocal对应的实体entry * 如果此ThreadLocal变量在当前线程中调用{@linkplain #get read} 方法 * 则会通过调用{@link #initialValue} 方法进行初始化 * 除非此值value是通过当前线程内置调用set方法设置 * 这可能导致在当前线程中多次调用initialValue方法初始化 * 1. 获取当前线程Thread对象，进而获取此线程对象中维护的ThreadLocalMap对象。 * 2. 判断`ThreadLocalMap`是否存在,如果存在,调用map.remove,以当前的`ThreadLocal`为key删除对应的`entry` */
         public void remove() { 
             // 获取当前线程Thread对象,进而获取此线程对象中维护的`ThreadLocalMap`对象
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
             // 如果`ThreadLocalMap`存在调用remove方法删除之,当前ThreadLocal对象为key
                 m.remove(this);
         }
    
        /** * 获取当前对象Thread对应维护的ThreadLocalMap * @param 当前线程 * @return 对应的ThreadLocalMap */
        ThreadLocalMap getMap(Thread t) { 
            return t.threadLocals;
        }

再来看看ThreadLocal的内部类ThreadLocalMap，ThreadLocalMap其内部利用Entry来实现的key-value的存储，类似HashMap的结构，如下代码，我们可以看出Entry的key就是ThreadLocal，而value就是值。同时Entry也是继承WeakReference，所以说Entry所对应得key得引用为一个弱引用。

static class Entry extends WeakReference<ThreadLocal<?>> { 
         /** The value associated with this ThreadLocal. */
         Object value;
    
         Entry(ThreadLocal<?> k, Object v) { 
             super(k);
             value = v;
         }
     }

### ThreadLocal代码样例 ###

通过一个例子来解释一下ThreadLocal得使用：

package com.asong.cloud;
    
    public class TestThreadLocal { 
        private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    
        public static void main(String[] args) { 
            for (int i = 0; i <10 ; i++) { 
                final int final1 = i;
                new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        threadLocal.set(final1);
                        try { 
                            Thread.sleep(1000);
                        }catch (Exception e)
                        { 
                            e.printStackTrace();
                        }
                        System.out.println("ThreadLocal: " + threadLocal.get());
                    }
                }).start();
            }
        }
    }

运行结果如下：

![在这里插入图片描述][20200119162205497.png]

[20200119162205497.png]: https://img-blog.csdnimg.cn/20200119162205497.png