13-J.U.C之ThreadLocal

分手后的思念是犯贱 2021-08-29 15:14 306阅读 0赞

### ThreadLocal ###

*  1. ThreadLoacal 是什么
 *  2. 使用示例
 *  3. ThreadLocal源码解析
 *   *  3.1 ThreadLocalMap
     *   *  3.1.1 set(ThreadLocal key, Object value)
         *  3.1.2 getEntry()
     *  3.2 ThreadLocal
     *   *  3.2.1 get()
         *  3.2.2 set(T value)
         *  3.2.3 initialValue()
         *  3.2.4 remove()
 *  4. ThreadLocal 为什么会内存泄漏

# 1. ThreadLoacal 是什么 #

该类提供了线程局部 (`thread-local`) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其`get` 或 `set` 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。

`ThreadLocal`实例通常是类中的 `private static` 字段，它们希望将状态与某一个线程（例如，用户 `ID` 或事务 `ID`）相关联。

所以`ThreadLocal`与线程同步机制不同，线程同步机制是多个线程共享同一个变量，而`ThreadLocal`是为每一个线程创建一个单独的变量副本，故而每个线程都可以独立地改变自己所拥有的变量副本，而不会影响其他线程所对应的副本。可以说`ThreadLocal`为多线程环境下变量问题提供了另外一种解决思路。

`ThreadLocal`定义了四个方法：

*  `get()`：返回此线程局部变量的当前线程副本中的值。
 *  `initialValue()`：返回此线程局部变量的当前线程的“初始值”。
 *  `remove()`：移除此线程局部变量当前线程的值。
 *  `set(T value)`：将此线程局部变量的当前线程副本中的值设置为指定值。

除了这四个方法，`ThreadLocal`内部还有一个静态内部类`ThreadLocalMap`，该内部类才是实现线程隔离机制的关键，`get()`、`set()`、`remove()`都是基于该内部类操作。`ThreadLocalMap`提供了一种用键值对方式存储每一个线程的变量副本的方法，`key`为当前`ThreadLocal`对象，`value`则是对应线程的变量副本。

对于`ThreadLocal`需要注意的有两点：

1、`ThreadLocal`实例本身是不存储值，它只是提供了一个在当前线程中找到副本值的`key`。

2、是`ThreadLocal`包含在Thread中，而不是`Thread`包含在ThreadLocal中。

下图是`Thread`、`ThreadLocal`、`ThreadLocalMap`的关系：

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

# 2. 使用示例 #

public class SeqCount { 
    
        private static ThreadLocal<Integer> seqCount = new ThreadLocal<Integer>(){ 
            // 实现initialValue()
            public Integer initialValue() { 
                return 0;
            }
        };
    
        public int nextSeq(){ 
            seqCount.set(seqCount.get() + 1);
    
            return seqCount.get();
        }
    
        public static void main(String[] args){ 
            SeqCount seqCount = new SeqCount();
    
            SeqThread thread1 = new SeqThread(seqCount);
            SeqThread thread2 = new SeqThread(seqCount);
            SeqThread thread3 = new SeqThread(seqCount);
            SeqThread thread4 = new SeqThread(seqCount);
    
            thread1.start();
            thread2.start();
            thread3.start();
            thread4.start();
        }
    
        private static class SeqThread extends Thread{ 
            private SeqCount seqCount;
    
            SeqThread(SeqCount seqCount){ 
                this.seqCount = seqCount;
            }
    
            public void run() { 
                for(int i = 0 ; i < 3 ; i++){ 
                    System.out.println(Thread.currentThread().getName() + " seqCount :" + seqCount.nextSeq());
                }
            }
        }
    }

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

# 3. ThreadLocal源码解析 #

`ThreadLocal`虽然解决了这个多线程变量的复杂问题，但是它的源码实现却是比较简单的。`ThreadLocalMap`是实现`ThreadLocal`的关键，我们先从它入手。

## 3.1 ThreadLocalMap ##

`ThreadLocalMap`其内部利用`Entry`来实现`key-value`的存储，如下：

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

从上面代码中可以看出`Entry`的`key`就是`ThreadLocal`，而`value`就是值。同时，`Entry`也继承`WeakReference`，所以说`Entry`所对应`key`（`ThreadLocal`实例）的引用为一个弱引用。

`ThreadLocalMap`的源码稍微多了点，我们就看两个最核心的方法`getEntry()`、`set(ThreadLocal key, Object value)`方法。

### 3.1.1 set(ThreadLocal key, Object value) ###

private void set(ThreadLocal<?> key, Object value) { 
    
        ThreadLocal.ThreadLocalMap.Entry[] tab = table;
        int len = tab.length;
    
        // 根据 ThreadLocal 的散列值，查找对应元素在数组中的位置
        int i = key.threadLocalHashCode & (len-1);
    
        // 采用“线性探测法”，寻找合适位置
        for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
             e != null;
             e = tab[i = nextIndex(i, len)]) { 
    
            ThreadLocal<?> k = e.get();
    
            // key 存在，直接覆盖
            if (k == key) { 
                e.value = value;
                return;
            }
    
            // key == null，但是存在值（因为此处的e != null），说明之前的ThreadLocal对象已经被回收了
            if (k == null) { 
                // 用新元素替换陈旧的元素
                replaceStaleEntry(key, value, i);
                return;
            }
        }
    
        // ThreadLocal对应的key实例不存在也没有陈旧元素，new 一个
        tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value);
    
        int sz = ++size;
    
        // cleanSomeSlots 清楚陈旧的Entry（key == null）
        // 如果没有清理陈旧的 Entry 并且数组中的元素大于了阈值，则进行 rehash
        if (!cleanSomeSlots(i, sz) && sz >= threshold)
            rehash();
    }

这个`set()`操作和我们在集合了解的`put()`方式有点儿不一样，虽然他们都是`key-value`结构，不同在于他们解决散列冲突的方式不同。集合`Map`的`put()`采用的是拉链法，而`ThreadLocalMap`的`set()`则是采用开放定址法。

`set()`操作除了存储元素外，还有一个很重要的作用，就是`replaceStaleEntry()`和`cleanSomeSlots()`，这两个方法可以清除掉`key = null` 的实例，防止内存泄漏。

在`set()`方法中还有一个变量很重要：`threadLocalHashCode`，定义如下：

private final int threadLocalHashCode = nextHashCode();

从名字上面我们可以看出`threadLocalHashCode`应该是`ThreadLocal`的散列值，定义为`final`，表示`ThreadLocal`一旦创建其散列值就已经确定了，生成过程则是调用`nextHashCode()`：

private static AtomicInteger nextHashCode = new AtomicInteger();
    
    private static final int HASH_INCREMENT = 0x61c88647;
    
    private static int nextHashCode() { 
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

`nextHashCode`表示分配下一个`ThreadLocal`实例的`threadLocalHashCode`的值，`HASH_INCREMENT`则表示分配两个`ThradLocal`实例的`threadLocalHashCode`的增量，从`nextHashCode`就可以看出他们的定义。

### 3.1.2 getEntry() ###

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);
    }

由于采用了开放定址法，所以当前`key`的散列值和元素在数组的索引并不是完全对应的，首先取一个探测数（`key`的散列值），如果所对应的`key`就是我们所要找的元素，则返回，否则调用`getEntryAfterMiss()`，如下：

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { 
        Entry[] tab = table;
        int len = tab.length;
    
        while (e != null) { 
            ThreadLocal<?> k = e.get();
            if (k == key)
                return e;
            if (k == null)
                expungeStaleEntry(i);
            else
                i = nextIndex(i, len);
            e = tab[i];
        }
        return null;
    }

这里有一个重要的地方，当`key = null`时，调用了`expungeStaleEntry()`方法，该方法用于处理`key = null`，有利于`GC`回收，能够有效地避免内存泄漏。

## 3.2 ThreadLocal ##

### 3.2.1 get() ###

返回当前线程所对应的线程变量。

public T get() { 
        // 获取当前线程
        Thread t = Thread.currentThread();
    
        // 获取当前线程的成员变量 ThreadLocalMap 
        ThreadLocalMap map = getMap(t);
    
        if (map != null) { 
            // 从当前线程的ThreadLocalMap获取相对应的Entry
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) { 
                @SuppressWarnings("unchecked")
    
                // 获取目标值 
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

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

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

首先通过当前线程获取所对应的成员变量`ThreadLocalMap`，然后通过`ThreadLocalMap`获取当前`ThreadLocal`的`Entry`，最后通过所获取的`Entry`获取目标值`result`。

### 3.2.2 set(T value) ###

设置当前线程的线程局部变量的值。

public void set(T value) { 
    	    Thread t = Thread.currentThread();
    	    ThreadLocalMap map = getMap(t);
    	    if (map != null)
    	        map.set(this, value);
    	    else
    	        createMap(t, value);
    	}

获取当前线程所对应的`ThreadLocalMap`，如果不为空，则调用`ThreadLocalMap`的`set()`方法，`key`就是当前`ThreadLocal`，如果不存在，则调用`createMap()`方法新建一个，如下：

void createMap(Thread t, T firstValue) { 
            t.threadLocals = new ThreadLocalMap(this, firstValue);
        }

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);
            }

### 3.2.3 initialValue() ###

返回该线程局部变量的初始值。

protected T initialValue() { 
    	    return null;
    	}

该方法定义为`protected`级别且返回为`null`，很明显是要子类实现它的，所以我们在使用`ThreadLocal`的时候一般都应该覆盖该方法。该方法不能显示调用，只有在第一次调用`get()`或者`set()`方法时才会被执行，并且仅执行`1`次。

### 3.2.4 remove() ###

将当前线程局部变量的值删除。

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

该方法的目的是减少内存的占用。当然，我们不需要显示调用该方法，因为一个线程结束后，它所对应的局部变量就会被垃圾回收。

# 4. ThreadLocal 为什么会内存泄漏 #

前面提到每个`Thread`都有一个`ThreadLocal.ThreadLocalMap`的`map`，该`map`的`key`为`ThreadLocal`实例，它为一个弱引用，我们知道弱引用有利于`GC`回收。当`ThreadLocal的key=null`时，`GC`就会回收这部分空间，但是`value`却不一定能够被回收，因为他还与`Current Thread`存在一个强引用关系，如下:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdfemhhb18_size_16_color_FFFFFF_t_70 3]  
      由于存在这个强引用关系，会导致`value`无法回收。如果这个线程对象不会销毁那么这个强引用关系则会一直存在，就会出现内存泄漏情况。所以说只要这个线程对象能够及时被`GC`回收，就不会出现内存泄漏。如果碰到线程池，那就更坑了。

那么要怎么避免这个问题呢？  
      在前面提过，在`ThreadLocalMap`中的`setEntry()`、`getEntry()`，如果遇到`key = null`的情况，会对`value`设置为null。当然我们也可以显示调用`ThreadLocal`的`remove()`方法进行处理。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdfemhhb18_size_16_color_FFFFFF_t_70]: /images/20210813/21a2e0962feb47daab9ada42f4923137.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdfemhhb18_size_16_color_FFFFFF_t_70 1]: /images/20210813/1287125d98544935af7db546020feb26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdfemhhb18_size_16_color_FFFFFF_t_70 2]: /images/20210813/5c75ab976fe34833bbe3d45d8e7e6e43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdfemhhb18_size_16_color_FFFFFF_t_70 3]: /images/20210813/b598b261ec004264b7a27fa38cb37e5f.png