多线程编程(3)之ThreadLocal 原理和使用场景

Myth丶恋晨 2023-06-06 03:38 27阅读 0赞

# 一、什么是ThreadLocal  #

**ThreadLocal 是 JDK** `java.lang` **包中的一个用来实现相同线程数据共享不同的线程数据隔离的一个工具。 我们来看下 JDK 源码中是如何解释的：**

This class provides thread-local variables. These variables differ from their normal counterparts in that each thread that accesses one (via its get or set method) has its own, independently initialized copy of the variable. ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread (e.g., a user ID or Transaction ID).
    
    Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the ThreadLocal instance is accessible; after a thread goes away, all of its copies of thread-local instances are subject to garbage collection (unless other references to these copies exist).

大致的意思是：

ThreadLocal 这个类提供线程局部变量，这些变量与其他正常的变量的不同之处在于，每一个访问该变量的线程在其内部都有一个独立的初始化的变量副本；ThreadLocal 实例变量通常采用`private static`在类中修饰。

只要 ThreadLocal 的变量能被访问，并且线程存活，那每个线程都会持有 ThreadLocal 变量的副本。当一个线程结束时，它所持有的所有 ThreadLocal 相对的实例副本都可被回收。

**一句话说就是 ThreadLocal 适用于每个线程需要自己独立的实例且该实例需要在多个方法中被使用（相同线程数据共享），也就是变量在线程间隔离（不同的线程数据隔离）而在方法或类间共享的场景。**

# **二、**ThreadLocal 的使用测试 #

**我们先通过两个例子来看一下 **`ThreadLocal` **的使用。**

**例子 1 普通变量：**

import java.util.concurrent.CountDownLatch;
    
    
    public class MyStringDemo {
        private String string;
    
        private String getString() {
            return string;
        }
    
        private void setString(String string) {
            this.string = string;
        }
    
        public static void main(String[] args) {
            int threads = 9;
            MyStringDemo demo = new MyStringDemo();
            CountDownLatch countDownLatch = new CountDownLatch(threads);
            for (int i = 0; i < threads; i++) {
                Thread thread = new Thread(() -> {
                    demo.setString(Thread.currentThread().getName());
                    System.out.println(demo.getString());
                    countDownLatch.countDown();
                }, "thread - " + i);
                thread.start();
            }
    
        }
    
    }

**程序的运行的随机结果如下：**

thread - 1
    thread - 2
    thread - 1
    thread - 3
    thread - 4
    thread - 5
    thread - 6
    thread - 7
    thread - 8
    
    Process finished with exit code 0

**从结果我们可以看出多个线程在访问同一个变量的时候出现的异常，线程间的数据没有隔离。下面我们来看下采用** `ThreadLocal` **变量的方式来解决这个问题的例子。**

**例子 2** `ThreadLocal` **变量：**

import java.util.concurrent.CountDownLatch;
    
    
    public class MyThreadLocalStringDemo {
        private static ThreadLocal<String> threadLocal = new ThreadLocal<>();
    
        private String getString() {
            return threadLocal.get();
        }
    
        private void setString(String string) {
            threadLocal.set(string);
        }
    
        public static void main(String[] args) {
            int threads = 9;
            MyThreadLocalStringDemo demo = new MyThreadLocalStringDemo();
            CountDownLatch countDownLatch = new CountDownLatch(threads);
            for (int i = 0; i < threads; i++) {
                Thread thread = new Thread(() -> {
                    demo.setString(Thread.currentThread().getName());
                    System.out.println(demo.getString());
                    countDownLatch.countDown();
                }, "thread - " + i);
                thread.start();
            }
        }
    
    }

**程序运行结果：**

thread - 0
    thread - 1
    thread - 2
    thread - 3
    thread - 4
    thread - 5
    thread - 6
    thread - 7
    thread - 8
    
    Process finished with exit code 0

从结果来看，这次我们很好的解决了多线程之间数据隔离的问题，十分方便。

这里可能有的朋友会觉得在例子 1 中我们完全可以通过加锁来实现这个功能。是的没错，加锁确实可以解决这个问题，但是在这里我们强调的是线程数据隔离的问题，并不是多线程共享数据的问题。假如我们这里除了`getString()` 之外还有很多其他方法也要用到这个 String，这个时候各个方法之间就没有显式的数据传递过程了，都可以直接中 `ThreadLocal` 变量中获取，这才是 `ThreadLocal` 的核心，**相同线程数据共享不同的线程数据隔离。**由于`ThreadLocal` 是支持泛型的，这里采用的是存放一个 `String` 来演示，其实可以存放任何类型，效果都是一样的。

# 三、**从源码分析ThreadLocal的实现** #

在分析源码前我们明白一个事那就是对象实例与 `ThreadLocal` 变量的映射关系是由线程 `Thread` 来维护的，对象实例与 `ThreadLocal` 变量的映射关系是由线程 `Thread` 来维护的，对象实例与 `ThreadLocal` 变量的映射关系是由线程 `Thread` 来维护的。重要的事情说三遍。换句话说就是对象实例与 `ThreadLocal` 变量的映射关系是存放的一个 `Map` 里面（这个 `Map` 是个抽象的 `Map` 并不是 `java.util` 中的 `Map` ），而这个 `Map` 是 `Thread` 类的一个字段！而真正存放映射关系的 `Map` 就是 `ThreadLocalMap`。看到这里，估计有很多人都会和我一样有一些疑问

1.  每个线程的变量副本是怎么存储的?
2.  ThreadLocal是如何实现多线程场景下的共享变量副本隔离?

带着疑问，来看一下ThreadLocal这个类的定义(默认情况下,JDK的源码都是基于1.8版本)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70][]

从ThreadLocal的方法定义来看,还是挺简单的。就几个方法：

*  get: 获取ThreadLocal中当前线程对应的线程局部变量
 *  set：设置当前线程的线程局部变量的值
 *  remove：将当前线程局部变量的值删除

另外，还有一个initialValue()方法，在前面的代码中有演示，作用是返回当前线程局部变量的初始值，这个方法是一个 `protected`方法，主要是在构造ThreadLocal时用于设置默认的初始值。

## 3.1set方法的实现 ##

set方法是设置一个线程的局部变量的值，相当于当前线程通过set设置的局部变量的值，只对当前线程可见。

![20191009180355667.png][]

*  `Thread.currentThread` 获取当前执行的线程
 *  `getMap(t)` ,根据当前线程得到当前线程的ThreadLocalMap对象，这个对象具体是做什么的?稍后分析
 *  如果map不为空，说明当前线程已经构造过ThreadLocalMap，直接将值存储到map中
 *  如果map为空，说明是第一次使用，调用 `createMap`构造

## 3.2ThreadLocalMap是什么? ##

我们来分析一下这句话， `ThreadLocalMapmap=getMap(t)`获得一个ThreadLocalMap对象，那这个对象是干嘛的呢?

其实不用分析，基本上也能猜测出来，Map是一个集合，集合用来存储数据，那么在ThreadLocal中，应该就是用来存储线程的局部变量的。 `ThreadLocalMap`这个类很关键.

ThreadLocalMap getMap(Thread t) {
            return t.threadLocals;
        }

t.threadLocals实际上就是访问Thread类中的ThreadLocalMap这个成员变量

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70 1][]

从上面的代码发现每一个线程都有自己单独的ThreadLocalMap实例，而对应这个线程的所有本地变量都会保存到这个map内.

## 3.3ThreadLocalMap是在哪里构造? ##

在 `set`方法中，有一行代码 `createmap(t,value);`，这个方法就是用来构造ThreadLocalMap，从传入的参数来看，它的实现逻辑基本也能猜出出几分吧.

/**
         * Create the map associated with a ThreadLocal.
         *
         * @param t the current thread
         * @param firstValue value for the initial entry of the table.
         */
        void createMap(Thread t, T firstValue) {
            t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
        }

`Threadt` 是通过 `Thread.currentThread()`来获取的表示当前线程，然后直接通过 `newThreadLocalMap`将当前线程中的 `threadLocals`做了初始化 ThreadLocalMap是一个静态内部类，内部定义了一个Entry对象用来真正存储数据。

static class ThreadLocalMap {
     static class Entry extends WeakReference<ThreadLocal<?>> {
                /** The value associated with this ThreadLocal. */
                Object value;
    
                Entry(ThreadLocal<?> k, Object v) {
                    super(k);
                    value = v;
                }
            }
    
    
    
            /**
             * Construct a new map including all Inheritable ThreadLocals
             * from given parent map. Called only by createInheritedMap.
             *
             * @param parentMap the map associated with parent thread.
             */
            private ThreadLocalMap(ThreadLocalMap parentMap) {
                Entry[] parentTable = parentMap.table;
                int len = parentTable.length;
                setThreshold(len);
                table = new Entry[len];
    
                for (int j = 0; j < len; j++) {
                    Entry e = parentTable[j];
                    if (e != null) {
                        @SuppressWarnings("unchecked")
                        ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                        if (key != null) {
                            Object value = key.childValue(e.value);
                            Entry c = new Entry(key, value);
                            int h = key.threadLocalHashCode & (len - 1);
                            while (table[h] != null)
                                h = nextIndex(h, len);
                            table[h] = c;
                            size++;
                        }
                    }
                }
            }
    
           //省略部分代码
    }

分析到这里，基本知道了ThreadLocalMap长啥样了，也知道它是如何构造的?那么我看到这里的时候仍然有疑问

*  Entry集成了 `WeakReference`,这个表示什么意思?
 *  在构造ThreadLocalMap的时候 `newThreadLocalMap(this,firstValue);`,key其实是this，this表示当前对象的引用，在当前的案例中，this指的是 `ThreadLocal<Integer>local`。那么多个线程对应同一个ThreadLocal实例，怎么对每一个ThreadLocal对象做区分呢？

## 3.4解惑WeakReference ##

weakReference表示弱引用，在Java中有四种引用类型，强引用、弱引用、软引用、虚引用。

使用弱引用的对象，不会阻止它所指向的对象被垃圾回收器回收。

在Java语言中, 当一个对象o被创建时, 它被放在Heap里. 当GC运行的时候, 如果发现没有任何引用指向o, o就会被回收以腾出内存空间. 也就是说, 一个对象被回收, 必须满足两个条件:

*  没有任何引用指向它
 *  GC被运行.

这段代码中，构造了两个对象a,b，a是对象DemoA的引用，b是对象DemoB的引用，对象DemoB同时还依赖对象DemoA，那么这个时候我们认为从对象DemoB是可以到达对象DemoA的。这种称为强可达(strongly reachable)

DemoA a=new Demo ();
    DemoB b=new DemoB(a);

如果我们增加一行代码来将a对象的引用设置为null，当一个对象不再被其他对象引用的时候，是会被GC回收的，但是对于这个场景来说，即时是a=null，也不可能被回收，因为DemoB依赖DemoA，这个时候是可能造成内存泄漏的

DemoA a=new Demo ();
    DemoB b=new DemoB(a);
    a=null;

通过弱引用，有两个方法可以避免这样的问题.

![20191009181755480.png][]

对于方法2来说，DemoA只是被弱引用依赖，假设垃圾收集器在某个时间点决定一个对象是弱可达的(weakly reachable)（也就是说当前指向它的全都是弱引用），这时垃圾收集器会清除所有指向该对象的弱引用，然后把这个弱可达对象标记为可终结(finalizable)的，这样它随后就会被回收。

试想一下如果这里没有使用弱引用，意味着ThreadLocal的生命周期和线程是强绑定，只要线程没有销毁，那么ThreadLocal一直无法回收。而使用弱引用以后，当ThreadLocal被回收时，由于Entry的key是弱引用，不会影响ThreadLocal的回收防止内存泄漏，同时，在后续的源码分析中会看到，ThreadLocalMap本身的垃圾清理会用到这一个好处，方便对无效的Entry进行回收。

### 解惑ThreadLocalMap以this作为key ###

在构造ThreadLocalMap时，使用this作为key来存储，那么对于同一个ThreadLocal对象，如果同一个Thread中存储了多个值，是如何来区分存储的呢？

答案就在 `firstKey.threadLocalHashCode&(INITIAL_CAPACITY-1)`

/**
             * 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) {
                table = new Entry[INITIAL_CAPACITY];
                int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
                table[i] = new Entry(firstKey, firstValue);
                size = 1;
                setThreshold(INITIAL_CAPACITY);
            }

关键点是 `threadLocalHashCode`，它相当于一个ThreadLocal的ID，实现的逻辑如下

private static int nextHashCode() {
            return nextHashCode.getAndAdd(HASH_INCREMENT);
        }

这里用到了一个非常完美的散列算法，可以简单理解为，对于同一个ThreadLocal下的多个线程来说，当任意线程调用set方法存入一个数据到Entry中的时候，其实会根据 `threadLocalHashCode`生成一个唯一的id标识对应这个数据，存储在Entry数据下标中。

## remove方法 ##

remove的方法比较简单，从Entry\[\]中删除指定的key就行。

private void remove(ThreadLocal<?> key) {
                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)]) {
                    if (e.get() == key) {
                        e.clear();
                        expungeStaleEntry(i);
                        return;
                    }
                }
            }

# **四、ThreadLocal的应用场景及问题** #

ThreadLocal的实际应用场景：

1.  比如在线程级别，维护session,维护用户登录信息userID（登陆时插入，多个地方获取）
2.  数据库的链接对象 `Connection`，可以通过ThreadLocal来做隔离避免线程安全问题

## 4.1问题 ##

ThreadLocal的内存泄漏。

ThreadLocalMap中Entry的key使用的是ThreadLocal的弱引用，如果一个ThreadLocal没有外部强引用，当系统执行GC时，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现一个key为null的Entry，而这个key=null的Entry是无法访问的，当这个线程一直没有结束的话，那么就会存在一条强引用链。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70 2][]

Thread Ref - > Thread -> ThreadLocalMap - > Entry -> value 永远无法回收而造成内存泄漏。

其实我们从源码分析可以看到，ThreadLocalMap是做了防护措施的：

*  首先从ThreadLocal的直接索引位置(通过ThreadLocal.threadLocalHashCode & (len-1)运算得到)获取Entry e，如果e不为null并且key相同则返回e。
 *  如果e为null或者key不一致则向下一个位置查询，如果下一个位置的key和当前需要查询的key相等，则返回对应的Entry，否则，如果key值为null，则擦除该位置的Entry，否则继续向下一个位置查询。

在这个过程中遇到的key为null的Entry都会被擦除，那么Entry内的value也就没有强引用链，自然会被回收。仔细研究代码可以发现，set操作也有类似的思想，将key为null的这些Entry都删除，防止内存泄露。

但是这个设计一来与一个前提条件，就是调用get或者set方法，但是不是所有场景都会满足这个场景的，所以为了避免这类的问题，我们可以在合适的位置手动调用ThreadLocal的remove函数删除不需要的ThreadLocal，防止出现内存泄漏。

所以建议的使用方法是：

*  将ThreadLocal变量定义成private static的，这样的话ThreadLocal的生命周期就更长，由于一直存在ThreadLocal的强引用，所以ThreadLocal也就不会被回收，也就能保证任何时候都能根据ThreadLocal的弱引用访问到Entry的value值，然后remove它，防止内存泄露。
 *  每次使用完ThreadLocal，都调用它的remove()方法，清除数据。

# **五、小结** #

在平时忙碌的工作中我们经常解决的是一个业务的需求，往往很少会涉及到底层的源码或者框架的具体实现代码。 其实这是很不好的，其实很多的东西的原理都是一样的，我们需要经常去看一下源码，了解一些底层的实现，不能总是停留在表层，代码看到多了，才能写出好的代码，并且还能学到很多东西。 随着我们知道的越来越多，我们会发现我们不知道的也越来越多。加油，共勉！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70]: /images/20230601/d5cc9a84ed7d4475a144c8e9ad182d18.png
[20191009180355667.png]: /images/20230601/980b1882629b4201b815be8bad89046d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70 1]: /images/20230601/112425c9907c4bf380754eb216d8a583.png
[20191009181755480.png]: /images/20230601/aed8ee3393af4cdb9f812ffffc653746.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70 2]: /images/20230601/a1af7bcdabf941c4a6a404ecced0df12.png