close

Mr.Muzi

一只很安静的monkey

Java多线程 - ThreadLocal解释

字数统计: 5.6k 阅读时长: 23 mins • 分类: 源码阅读 • 标签: JDK 1.7, 多线程

  关于 java.io.ThreadLocal 的部分笔记，ThreadLocal维护了多线程环境中每个线程的私有变量内容，保证这些私有变量内容只对特定的线程可见，其他线程无法访问、修改非自身线程中的变量内容。本文演示代码段的执行环境基于JDK版本1.7。

概述

  ThreadLocal实现了多线程环境中每个线程独自访问、维护其私有的变量实例的特性。在实际的多线程环境中，每个线程内部维护了一个ThreadLocalMap集合，集合中的每个Entry维护了一个Threadlocal引用和线程内变量的映射关系。每个Threadlocal引用具有唯一的用于执行散列操作的threadLocalHashCode字段值，因此如果某个线程内部需要多个变量的话只需要创建多个Threadlocal实例，并将Threadlocal实例和变量的映射关系维护到线程的ThreadLocalMap集合中即可。当前线程可以通过ThreadLocal提供的get和set()等方法完成对线程内私有变量的访问操作。

  由于每个线程都维护了一个ThreadLocalMap集合，因此Thread、ThreadLocalMap、ThreadLocal这三者之间的关系如图1所示：

图 - 1 Thread、ThreadLocal、ThreadLocalMap关系
 

  ThreadLocalMap是Threadlocal的内部类，用来维护单个线程内的可用变量实例。Entry是ThreadLocalMap集合的底层数据结构。Entry的父类是弱引用的实现类，内部拥有一个类型为Object的value字段。通过Entry实现了Threadlocal实例和线程内变量对象的映射关系。ThreadLocal的结构如图1所示(PS：实线箭头为强引用，虚线箭头为弱引用)：

图 - 2 ThreadLocal结构$图^1$
 

  Entry之所以继承自弱引用，是出于如下的考虑：

  如图2所示，Entry实例的key以弱引用的方式指向ThreadLocal实例，因此当ThreadLocalRef不再引用ThreadLocal实例时，弱引用可以保证ThreadLocal实例对象在每次GC时都能得到清除以释放其占用的内存空间。如果该ThreadLocal实例不再使用，那么还需要断开value和Map对该Entry的指向关系，这样当前Entry和value指向的对象实例就都会被GC处理并释放空间了。

  ThreadLocal如果使用不当的话容易出现内存泄漏的问题。图2中出现的弱引用解决了ThreadLocal实例可以被GC回收的问题，但是图2中value引用和ThreadLocalMap与Entry实例的引用都是强引用。当ThreadLocal被回收了以后，其对应的value也应该被回收掉，但是强引用不允许这么做，所以在确定线程内私有变量不会再次使用时需要调用remove()方法断开value以及Entry实例的引用关系，保证内存资源可以顺利被回收。除此之外，在set()方法中也包含了检测并删除无效元素的操作过程。

 

继承关系

1
2
3
// ThreadLocal
--java.lang.Object
  --java.lang.ThreadLocal<T>

 

实现接口

NIL

 

ThreadLocal<T>

Constructor Summary

public ObjectInputStream(InputStream in)

1
2
public ThreadLocal() {
}

  创建一个ThreadLocal实例。

部分方法

ThreadLocalMap getMap(Thread t)

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

  获取当前线程t维护的ThreadLocal实例。

public T get()

1
2
3
4
5
6
7
8
9
10
public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

  获取当前线程t维护的线程私有变量副本的值。

  基本操作是首先取得当前线程信息，然后拿到当前线程维护的ThreadLocalMap集合，然后从中取出当前ThreadLocal实例映射的变量并返回。如果当前线程维护的ThreadLocalMap集合不存在，或者当前线程维护的局部变量的值不存在，那么设置一个初始值并返回这个初始值。底层调用ThreadLocalMap.getEntry方法完成操作。

1
2
3
4
5
6
7
8
9
10
private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

  生成初始值并赋值。

  由于ThreadLocal存储的是Object，所以生成初始值的过程直接返回null。得到当前线程和当前线程维护的ThreadLocalMap后，将当前线程的变量的初始值设置为value。最后返回设置的value。底层调用ThreadLocalMap.set方法完成操作。

  initialValue()的代码非常简单，具体如下：

1
2
3
protected T initialValue() {
    return null;
}

public void set(T value)

1
2
3
4
5
6
7
8
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

  将当前线程中的局部变量的值设置为入参value。

  操作过程很简单，取得当前线程和线程维护的ThreadLocalMap实例，之后建立当前value和ThreadLocal实例的映射关系。如果map不存在，那么就为当前线程实例化一个map集合并将ThreadLocal实例和value的映射关系存入集合中。底层调用ThreadLocalMap.set方法完成操作。

public void remove()

1
2
3
4
5
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

  协助子类读取和验证它们自己的流头部，过程中会读取和校验魔数和版本号。这两个数都是序列化过程中写入到流里的。底层调用ThreadLocalMap.remove方法完成操作。

void createMap(Thread t, T firstValue)

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

  为当前线程创建一个ThreadLocalMap集合。构造参数是当前ThreadLocal实例引用和value值。

static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap)

1
2
3
static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
    return new ThreadLocalMap(parentMap);
}

  为当前线程创建一个ThreadLocalMap集合。构造参数是一个ThreadLocalMap集合。

T childValue(T parentValue)

1
2
3
T childValue(T parentValue) {
    throw new UnsupportedOperationException();
}

  这个方法是为InheritableThreadLocal设计的，ThreadLocal自身对该方法不支持，所以直接抛出异常。

 

ThreadLocalMap

Fields

Entry

1
2
3
4
5
6
7
8
9
static class Entry extends WeakReference<ThreadLocal> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal k, Object v) {
        super(k);
        value = v;
    }
}

  Entry是ThreadLocalMap集合中的底层数据结构。Entry自身是一个弱引用对象，该弱引用指向的对象是当前ThreadLocal实例。Entry内部还有一个value属性，该属性字段存储了单个线程中的一个变量的数据内容。

Constructor Summary

ThreadLocalMap(ThreadLocal firstKey, Object firstValue)

1
2
3
4
5
6
7
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);
}

  初始化一个当前线程需要维护的ThreadLocalMap集合实例。该集合中维护了当前线程独享的若干个变量信息。

  根据入参ThreadLocal实例来确定ThreadLocal-value键值对在ThreadLocalMap中底层数组结构的下标索引，之后生成一个新的Entry实例并将该对象放入到计算得到的下标位置处。最后完成扩容阈值的设定。

private ThreadLocalMap(ThreadLocalMap parentMap)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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) {
            ThreadLocal key = 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集合实例。该方法仅适用于InheritableThreadLocal实现。

  在完成ThreadLocalMap实例对象的初始化相关工作后，遍历入参ParentMap中的元素，依次将其加入到新创建的ThreadLocalMap集合中。

部分方法

private Entry getEntry(ThreadLocal key)

1
2
3
4
5
6
7
8
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);
}

  获取当前线程中某个变量的键值对映射实体。

  在获取过程中，首先根据ThreadLocal的threadLocalHashCode属性来确定该键值对在当前ThreadLocalMap集合中的下标位置。threadLocalHashCode保证了每个ThreadLocal实例都会有一个唯一的int值，以此来保证ThreadLocal实例可以正确的参与到ThreadLocalMap集合的运算中。该值是通过如下代码来获取的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * 每个ThreadLocal实例会有一个唯一的int型值。final关键字保证了该字段只会被创建一次，保证了不变性
 */
private final int threadLocalHashCode = nextHashCode();
/**
 * 所有ThreadLocal实例共享该AtomicInteger实例
 */
private static AtomicInteger nextHashCode = new AtomicInteger();

/**
 * 增量0x61c88647在table的长度是2的n次方的大小的时候，效果非常好，会最大程度均匀分布，减少冲突。
 */
private static final int HASH_INCREMENT = 0x61c88647;
/**
 * 具体的生成方法，每个ThreadLocal对象初始化之后都会得到一个唯一的int值，且该值是递增的。
 */
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}

  在获取了下标位置之后，如果该位置存在有效的键值对实体对象且该对象的弱引用指向的就是当前传入的ThreadLocal实例，那么就返回该键值对，否则调用getEntryAfterMiss()方法按照散列冲突的场景查找对象。

private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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未找到对应Entry实例时调用当前方法完成数据查找过程。

  当该方法被调用时，说明要获取的Entry可能存在散列冲突，而在ThreadLocalMap中，解决散列冲突的思想是开放定址法法中的线性探测再散列，所以从入参下标位置 i 开始，每次向后移动一个空间位置检查是否存在和入参key匹配的Entry实体。

  在比较过程中如果发现了可以匹配入参key的Entry实例，那么就返回该实例。如果发现引用为null，那么需要执行清空操作，清除无效的Entry释放空间。

private static int nextIndex(int i, int len)

1
2
3
private static int nextIndex(int i, int len) {
    return ((i + 1 < len) ? i + 1 : 0);
}

  开发定址法法中的线性探测再散列函数，每次向后偏移一个位置。

private static int prevIndex(int i, int len)

1
2
3
private static int prevIndex(int i, int len) {
    return ((i - 1 >= 0) ? i - 1 : len - 1);
}

  和nextIndex()函数相反，当前方法执行的是前向遍历，每次向前偏移一个位置。

private int expungeStaleEntry(int staleSlot)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal k = e.get();
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

  清除当前线程的ThreadLocalMap集合中的无效Entry实例。

  第6 ~ 7行代码的执行顺序保证了Entry实例中的ThreadLocal实例对象和当前线程中的变量对象的引用都会被置为null从而在GC过程中会被回收掉。如果这两行代码的执行顺序颠倒一下则会导致当前线程的变量对象的引用仍然和Entry实例有联系使得该变量占用的内存得不到及时释放。

  从入参staleSlot执行的位置开始遍历，如果发现Entry实例的引用已经无效，那么就把该Entry及其内部的value全部清空，反之则重新计算该Entry在当前ThreadLocalMap集合中的下标位置。

private void set(ThreadLocal key, Object value)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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();
}

  将某个ThreadLocal实例和对应的变量内容存入到当前线程的ThreadLocalMap集合中。

  第9行代码根据Threadlocal的threadLocalHashCode字段做取模运算得到了在集合的下标位置。从该下标位置开始遍历，如果发现了key一致的Entry实例，那么用入参value值替换当前Entry实例的value。如果发现当前Entry的引用指向无效，那么就调用replaceStaleEntry()函数完成替换操作。

  如果在当前ThreadLocalMap集合中尚未发现可以匹配当前ThreadLocal的Entry实例，那么就新建一个Entry实例，并将该实例加入到当前集合的下标位置处。最后根据当时的实际情况决定是否需要调用rehash()方法完成元素调整操作。

private void replaceStaleEntry(ThreadLocal key, Object value, int staleSlot)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
private void replaceStaleEntry(ThreadLocal key, Object value, int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // Back up to check for prior stale entry in current run.
    // We clean out whole runs at a time to avoid continual
    // incremental rehashing due to garbage collector freeing
    // up refs in bunches (i.e., whenever the collector runs).
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal k = e.get();

        // If we find key, then we need to swap it
        // with the stale entry to maintain hash table order.
        // The newly stale slot, or any other stale slot
        // encountered above it, can then be sent to expungeStaleEntry
        // to remove or rehash all of the other entries in run.
        if (k == key) {
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // Start expunge at preceding stale entry if it exists
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // If we didn't find stale entry on backward scan, the
        // first stale entry seen while scanning for key is the
        // first still present in the run.
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // If key not found, put new entry in stale slot
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // If there are any other stale entries in run, expunge them
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

  用入参value替换掉当前ThreadLocalMap集合中key为入参key且匹配key的第一个无效元素的下标位置staleSlot。

  方法最开始会遍历集合，确定第一个无效的元素位置。所以第10 ~ 15行代码做的就是这个事情，从当前staleSlot位置向前遍历找到第一个无效元素的下标索引。从第19行代码开始，执行真正的替换操作。这里有个地方需要注意一下：开始遍历的位置是在staleSlot位置的下一个位置。因为在调用当前方法时，已经确认了传入的staleSlot位置是无效元素的，所以可以正确的从下一个位置开始遍历和检查。在遍历过程中，如果当前Entry元素的引用指向和入参ThreadLocal一致，那么就将当前位置的Entry元素和staleSlot位置的元素完成交换操作。

  第36 ~ 37代码的判断表明如果在第10 ~ 15行代码执行完成后发现staleSlot位置之前的元素都是有效的，那么当前位置 i 就是找到的第一个无效元素位置。第38行代码会在完成无效元素的清除工作后返回到方法调用处。

  第45 ~ 46行代码中，如果当前Entry元素无效，且发现staleSlot位置之前的元素都是有效的，那么当前位置 i 就是找到的第一个无效元素位置。

  第19 ~ 47行的遍历会一直进行直到遇到第一个不存储Entry实例的下标位置。

  第50 ~ 51行代码完成了value值的替换更新操作。如果发现维护的第一个无效元素位置和入参staleSlot位置不一致，那么就清除自第一个无效元素位置起的无效元素内容。

private boolean cleanSomeSlots(int i, int n)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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;
}

  判断是否需要清空当前ThreadLocalMap集合中的无效元素。

  从当前下标 i 开始（不包括 i），判断集合中的元素是否有效，如果无效，那么置removed标签为true，且调用方法expungeStaleEntry()完成无效元素的清除操作。

  需要注意的是，这个方法的时间复杂度因为实际情况的不同而不一样。如果当前ThreadLocalMap集合确实存在无效元素，那么由于需要遍历和移动元素的缘故，导致其复杂度为O(n)。相反，如果在最开始的$log(n)$次操作中都没有发现无效的元素，那么就认为不需要做无效元素清除。

  个人认为这么做的原因可能是出于执行效率的考虑吧。

private void remove(ThreadLocal key)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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变量实例。

  根据threadLocalHashCode找到对应的元素，执行Entry.clear()方法完成引用关系断开的操作。这样就完成了Entry实例的删除操作，之后在GC执行时这些被断开的引用就会被GC回收掉并释放了其占用的内存。

  最后会调用expungeStaleEntry()方法重新整理当前ThreadLocalMap集合中元素的存储位置关系。

private void rehash()

1
2
3
4
5
6
7
private void rehash() {
    expungeStaleEntries();

    // Use lower threshold for doubling to avoid hysteresis
    if (size >= threshold - threshold / 4)
        resize();
}

  重新排列当前ThreadLocalMap集合的元素存储位置。

  首先调用 expungeStaleEntries()方法完成无效元素的清空操作。之后如果当前集合存储的Entry实例个数超过了当前ThreadLocalMap集合容量的一半（threshold是当前容量的$\frac{2}{3}$，所以第5行代码>=的右边部分的值为$\frac{1}{2}$当前容量），那么就调用resize()方法执行扩容处理。扩容规则是按照当前集合容量的两倍进行扩容。

private void expungeStaleEntries()

1
2
3
4
5
6
7
8
9
private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        if (e != null && e.get() == null)
            expungeStaleEntry(j);
    }
}

  遍历整个ThreadLocalMap集合，清除无效的Entry引用。底层直接调用expungeStaleEntry()方法完成操作。

private void resize()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }

    setThreshold(newLen);
    size = count;
    table = newTab;
}

  实际完成ThreadLocalMap集合扩容操作的方法。扩容规则是按照当前集合容量的两倍进行扩容。

  在得到当前集合的容量后，按照两倍于当前集合容量的规则实例化一个新的Entry数组，遍历整个当前集合的数组，按照插入的过程将当前集合中的所有Entry元素全部插入到新的数组中。最后重新计算新的扩容阈值，并将新的数组指向table属性字段。

 

涉及基础知识点

  1. Hash冲突的解决方案：

      常用的方法有开放定址法、再哈希法、链地址法、建立公共溢出区等。其中，开放定址法又可细分为线性探测再散列、二次探测再散列和伪随机探测再散列等方法。

      ThreadLocalMap采用的开放定址法中的线性探测再散列思想。开放定址法的基本思想是：如果关键字key的散列地址根据散列函数计算后出现冲突时，以计算得到的地址为基础，调用如下的再散列函数完成新的散列地址的计算：

    在线性探测再散列法中，$d_i = 1,2,3,4,5,6,\cdots,m$ 。其实就是当发生冲突时每次向后偏移一个单位，检查是否为空闲位置。

  2. 强引用、软引用、弱引用的区别：

    强引用：应用最频繁的一种引用方式，如果一个对象拥有强引用，那么GC将不会对其尝试进行垃圾回收操作，内存空间不足时通过抛出OutOfMemoryException异常的方式来提示GC回收异常。只有当对象的引用被清除后，GC才会对其尝试进行回收操作。示例如下：

    1
    2
    Object testObj = new Object();   //  强引用
    testObj = null; //GC可回收

    软引用：如果一个对象拥有软引用，那么当内存空间足够时，GC不会对其尝试进行垃圾回收操作，如果内存空间不足时，GC会尝试回收其占用的内存空间。示例如下：

    1
    2
    String str=new String("MARCUS");                                     // 强引用
    SoftReference<String> testObj=new SoftReference<String>(str);     // 软引用

    弱引用：如果一个对象拥有弱引用，不管内存空间是否足够，GC工作时都会回收弱引用对象占用的内存空间。示例如下：

    1
    2
    String str=new String("MARCUS");    // 强引用
    WeakReference<String> testObj = new WeakReference<String>(str); // 弱引用

    如图3和图4所示：

    图 - 3 弱引用关系建立
     

    创建的弱引用关系在str还持有对“marcus”对象的引用时，GC不会对其做任何处理。

    图 - 4 强引用关系丢弃，弱引用对象被GC处理
     

    当str对象不再持有对“marcus”对象的引用时，此时“marcus”对象是一个弱引用，原来对它的强引用str不再对其持有引用，所以GC可以对其进行回收处理。

 

参考文献

  1. 陶邦仁. 深入JDK源码之ThreadLocal类 [E]
  2. 技术世界. Java进阶（七）正确理解Thread Local的原理与适用场景 [E]
  3. bear13. ThreadLocal源码浅析 [E]
  4. 你听__. 一篇文章，从源码深入详解ThreadLocal内存泄漏问题 [E]

 
 
 
 

------------- End of this article, thanks! -------------
 


  版权声明：本文由N.C.Lee创作和发表，采用署名(BY)-非商业性使用(NC)-相同方式共享(SA)国际许可协议进行许可，转载请注明作者及出处。
  本文作者为 N.C.Lee
  本文标题为 Java多线程 - ThreadLocal解释
  本文链接为 https://marcuseddie.github.io/2019/java-multiThread-ThreadLocal.html