• ThreadLocal原理

    文章目录

    1、ThreadLocal简介

    ThreadLocal叫做线程变量，意思是ThreadLocal中存放的变量只属于本线程,该变量对其他线程而言是线程隔离的。一个ThreadLocal对象只属于一个Thread，创建的变量也就是在本线程内，所以这个添加的变量只有自己才可以访问到。

    ThreadLocal 提供了线程本地的实例。它与普通变量的区别在于，每个使用该变量的线程都会初始化一个完全独立的实例副本。

    下面从图上了解一下ThreadLocal：

    在这里插入图片描述

    2、ThreadLocal和Synchronize的区别

    • ThreadLocal本地线程变量,线程自带的变量副本(实现了每一个线程副本都有一个专属的本地变量,主要解决的就是让每一个线程绑定自己的值,自己用自己的,不跟别人争抢。通过使用ThreadLocal的get()和set()方法,获取默认值或将其值更改为当前线程所存的副本的值从而避免了线程安全的问题)
    • synchronized或者lock,有个管理员,好比,现在大家签到,多个同学(线程),但是只有一只笔,只能同一个时间,只有一个线程(同学)签到,加锁(同步机制是以时间换空间,执行时间不一样,类似于排队)

    总结来讲：

    1. Synchronize用于线程间的数据共享，而ThreadLocal用于线程间的数据隔离
    2. Synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。

    一句话理解ThreadLocal，向ThreadLocal里面存东西就是向当前线程的threadLocals(ThreadLocal.ThreadLocalMap，是个map)里面存东西（<key, value> = <ThreadLocal, value>）。

    下面用代码分别使用ThreadLocal和synchronize

    使用Synchronize计算资源的总体数据

    /**
 * 需求1 ：5个销售卖房子，集团只关注销售的总数，要求的是总体数据，因此使用Synchronize
 *
 * @Author :漠殇
 * @Data ：Create in 10:03 2022/6/26
 */
public class ThreadLocalDemo1 {
    public static void main(String[] args) {
        House house = new House();

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                int size = new Random().nextInt(5) + 1;
                System.out.println(size);
                for (int i1 = 0; i1 < size; i1++) {
                    house.sale();
                }
            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("共销售" + house.saleCount + "套房子");
    }
}

class House {
    int saleCount;
    public synchronized void sale() {
        ++saleCount;
    }
}

//3
//2
//2
//1
//5
//共销售13套房子

    • 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

    使用ThreadLocal计算每个销售卖出了多少房子

    /**
 * 需求2： 5个销售买房子，需要统计各自的销售额，按照销售额提成
 *
 * @Author :漠殇
 * @Data ：Create in 10:03 2022/6/26
 */
public class ThreadLocalDemo1 {
    public static void main(String[] args) {
        House house = new House();

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                int size = new Random().nextInt(5) + 1;
//                System.out.println(size);
                try {
                    for (int i1 = 0; i1 < size; i1++) {
                        house.sale();
                        house.saleByThreadLocal();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t" + "号销售卖出" +
                            house.threadLocal.get());
                } finally {
                    house.threadLocal.remove(); // 使用完要remove，否则就可能会产生内存泄漏
                }
            }).start();
        }

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("共销售" + house.saleCount + "套房子");
    }
}

class House {
    int saleCount;
    public synchronized void sale() {
        ++saleCount;
    }

    // 不建议使用，jdk8后有更清爽的写法
//    ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
//        @Override
//        protected Integer initialValue() {
//            return 0;
//        }
//    };

    // 建议使用 相当于将初始值设为0
    ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void saleByThreadLocal() {
        threadLocal.set(threadLocal.get() + 1);
    }
}

//Thread-3	号销售卖出3
//Thread-2	号销售卖出2
//Thread-1	号销售卖出2
//Thread-0	号销售卖出1
//Thread-4	号销售卖出5
//共销售13套房子

    • 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
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

    3、ThreadLocal源码理解

    3.1 Thread与ThreadLocalMap

    从Thread看起：

    public class Thread implements Runnable {
    // 与此线程有关的ThreadLocal值。由ThreadLocal类维护，其中ThreadLocalMap是ThreadLocal的内部类
    ThreadLocal.ThreadLocalMap threadLocals = null;
    
    // 与此线程有关的inheritableThreadLocals值。由inheritableThreadLocals类维护
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    从上面Thread类 源代码可以看出，Thread类中有一个threadLocals和inheritableThreadLocals变量，他们都是ThreadLocalMap类型的变量，我们可以把ThreadLoaclMap理解为为ThreadLocal类定制化的HashMap。

    默认情况下这两个变量都是 null，只有当前线程调用 ThreadLocal类的set或get方法时才创建他们

    但为什么不通过Thread类调用get、set，而是通过ThreadLocal threadLocal.set() 、get() 呢?

    • Thread类里面只是声名了ThreadLocalMap，但是并未初始化
    • ThreadLocal在自己的getset方法中初始化了ThreadLoaclMap，并且传递了最终的变量值value，以及对value进行装填

    3.2 ThreadLocal

    public class ThreadLocal<T> {
    // 默认初始化，如果ThreadLocal没有进行初始化，进行get操作，会返回null
    protected T initialValue() {
        return null;
    }

    // 函数式初始化
    public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }
    
    
    public T get() {
        Thread t = Thread.currentThread();
        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();
    }
    
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
    
    public void remove() {
        ThreadLocalMap m = getMap(Thread.currentThread());
        if (m != null)
            m.remove(this);
    }
}

    • 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

    我们单独对每个方法进行解释

    3.2.1 ThreadLocal的set()方法

    public void set(T value) {
    // 获取当前线程，这是一个native方法
    Thread t = Thread.currentThread();
    //获取线程属性中的ThreadLocalMap，如果threadLocalMap不为空
    //则直接更新要保存的值，否则创建threadLocalMap，并赋值
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        // 初始化threadlocalMap，并赋值
        createMap(t, value);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    从上面的代码可以看出，ThreadLocal set赋值的时候首先会获取当前线程thread,并获取thread线程中的ThreadLocalMap属性。如果map属性不为空，则直接更新value值，如果map为空，则实例化threadLocalMap,并将value值初始化。

    那么ThreadLocalMap又是什么呢，还有createMap又是怎么做的，我们继续往下看。

    //ThreadLocalMap是存在ThreadLocal的一个内部类
static class ThreadLocalMap {

    /**
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    可看出ThreadLocalMap是ThreadLocal的内部静态类，而它的构成主要是用Entry来保存数据 ，而且还是继承的弱引用。在Entry内部使用ThreadLocal作为key，使用我们设置的value作为value

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

//ThreadLocalMap 构造方法
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);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    3.2.2 ThreadLocal的get()

    public T get() {
    // 获取当前Thread
    Thread t = Thread.currentThread();
    // 获取当前Thread对应的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    // 如果map不为空
    if (map != null) {
        // 获取Thread对应的ThreadLocal为键，在map中取得对应的Entry
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 如果Entry不为空，获得对应的值
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //如果对ThreadLocalMap为null。,执行初始化方法，且此方法只执行一次
    return setInitialValue();
}

// 初始化ThreadLocalMap
private T setInitialValue() {
    // 如果创建Thread时不进行初始化，就会调用此方法，value为null
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

// 默认的初始化
protected T initialValue() {
    return null;
}

    • 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

    3.2.3 ThreadLocal的remove()

    // 如果ThreadLocalMap不是null，调用remove()
public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

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();
            //通过重新散列位于staleSlot和下一个空槽之间的任何可能冲突的条目来删除陈旧的条目。这还会删除尾随null之前的任何陈旧条目。
            expungeStaleEntry(i);
            return;
        }
    }
}

// 将引用设为null，下一次GC就会将其回收掉
public void clear() {
    this.referent = null;
}

//这是expungeStaleEntry(i);的部分代码，可以看到，如果key为null，那么也会将value置为null，让GC将value也回收掉
if (k == null) {
    e.value = null;
    tab[i] = null;
    size--;
}

    • 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

    remove方法，直接将ThrealLocal 对应的值从当前相差Thread中的ThreadLocalMap中删除。为什么要删除，这涉及到内存泄露的问题。

    实际上 ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用，弱引用的特点是，如果这个对象只存在弱引用，那么在下一次垃圾回收的时候必然会被清理掉。

    所以如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候会被清理掉的，这样一来 ThreadLocalMap中使用这个 ThreadLocal 的 key 也会被清理掉。但是，value 是强引用，不会被清理，这样一来就会出现 key 为 null 的 value。

    ThreadLocal其实是与线程绑定的一个变量，如此就会出现一个问题：如果没有将ThreadLocal内的变量删除（remove）或替换，它的生命周期将会与线程共存。通常线程池中对线程管理都是采用线程复用的方法，在线程池中线程很难结束甚至于永远不会结束，这将意味着线程持续的时间将不可预测，甚至与JVM的生命周期一致。举个例字，如果ThreadLocal中直接或间接包装了集合类或复杂对象，每次在同一个ThreadLocal中取出对象后，再对内容做操作，那么内部的集合类和复杂对象所占用的空间可能会开始持续膨胀。

    4、ThreadLocal常见使用场景

    如上文所诉，ThreadLocal适用两种场景

    1. 每个线程需要有自己单独的实例

    2. 实例在多个方法中共享，但不希望被多线程共享

    对于第二点，常见的就是web中的一次请求，每产生一个请求，就会产生一个线程去单独处理这个请求，我们就可以将session或者id放入ThreadLocal中，从过滤器，拦截器，Controller、Service、Dao从始至终都存在该变量。

    5、ThreadLocal使用原理

    ThreadLocal的主要用途是实现线程间变量的隔离，表面上他们使用的是同一个ThreadLocal， 但是实际上使用的值value却是自己独有的一份。用一图直接表示threadlocal 的使用方式。

    在这里插入图片描述

    从图中我们可以当线程使用ThreadLocal 时，是将ThreadLocal 当做当前线程Thread的属性ThreadLocalMap 中的一个Entry的key值，实际上存放的变量是Entry的value值，我们实际要使用的值是value值。value值为什么不存在并发问题呢，因为它只有一个线程能访问。

    ThreadLocal 我们可以当做一个索引看待，可以有多个ThreadLocal 变量，不同的ThreadLocal 对应于不同的value值，他们之间互不影响。ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。

    6、ThreadLocal内存泄漏

    Entry将ThreadLocal作为一个key，值作为value保存，他继承自WeakReference, super(k);代表了ThreadLocal对象是一个弱引用

    static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    主要有两个原因：

    1. 没有手动删除这个Entry
    2. CurrentThread当前线程仍然在运行

    对于第一点，只有使用完ThreadLocal，调用其remove()删除对应的Entry，就可以避免内存泄漏

    对于第二点：

    1. ThreadLocalMap作为Thread的一个变量，只要Thread运行，那么ThreadLocalMap就不会被清理掉。

    2. 通过上图可以看到，ThreadLocal运行在一个方法中，在虚拟机栈的局部变量表中某个slot上，指向了内存空间中该ThreadLocal对象，假设调用了get方法后，ThreadLocalMap中的一个Entry指向了ThreadLocal实例，且是弱引用，该方法执行完成，虚拟机栈释放。此时只有ThreadLocalMap中的一个Entry指向ThreadLocal对象

    3. 此时发生GC，根据弱引用的特点，如果一个对象只有弱引用，该对象将被回收，此时ThreadLocalMap中出现一个entry(null, Entry)

    4. ThreadLocalMap中就会出现 key 为 null 的 Entry。假如我们不做任何措施的话，value 永远无法被 GC 回收，这个时候就可能会产生内存泄露。

    总结：

    由于ThreadLocalMap 的生命周期跟 Thread 一样长，对于重复利用的线程来说，如果没有手动删除（remove()方法）对应 key 就会导致entry(null，value)的对象越来越多，从而导致内存泄漏．

    7、为什么不将key设置为强引用

    那么为什么ThreadLocalMap的key要设计成弱引用呢？其实很简单，如果key设计成强引用且没有手动remove()，那么key会和value一样伴随线程的整个生命周期。

    假设在业务代码中使用完ThreadLcoal，ThreadLocal ref被回收了，但是ThreadLocalMap强引用了Threadlocal（Key就是ThreadLocal），造成了ThreadLocal无法被回收。

    在没有手动回收Entry以及CurrentThread依然运行的前提下，始终有强引用链 CurrentThread Ref -> CurrentThread -> ThreadLocalMap -> entryEntry就不会被回收( Entry中包括了ThreadLocal实例和value), 导致Entry内存泄漏

    8、ThreadLocal清除脏Entry

    8.1 对于get方法清除脏Entry

    public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        // 这里调用getEntry()
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}


private Entry getEntry(ThreadLocal<?> key) {
    // 找到key所在的table的下标
    int i = key.threadLocalHashCode & (table.length - 1);
    // 如果找到的entry数组不为null且entry的key==key，返回value
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        // 没有找到，开始顺着entry找
        return getEntryAfterMiss(key, i, e);
}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;

    // 如果entry不为null
    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null) //发现了为null的key
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len); //获取下一个entey
        e = tab[i];
    }
    return null;
}

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
 
    // expunge entry at staleSlot 删除null为键对应的value和对应的entry
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null 重新hash，直到遇到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) { //删除null为键对应的value和对应的entry
            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;
}

    • 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
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81

    8.2 对应set方法清除脏entry

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

private void set(ThreadLocal<?> key, Object value) {

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

        // 如果发现为null的键，调用replaceStaleEntry()
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}


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.
        // 如果我们在向后扫描时没有找到过时的条目，则在扫描key时看到的第一个过时条目仍然在运行中出现，记录
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // If key not found, put new entry in stale slot 如果没有发现key，删除
    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);
}

// 清除脏数据
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;
}

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

    • 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
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154

    9、如何正确的使用ThreadLocal

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

    参考：

    史上最全ThreadLocal 详解（一）

    史上最全ThreadLocal 详解（二）

    ThreadLocal原理

  • 相关阅读:
    Python【多分支选择结构】
    C语言典范编程
    Codeforces Round #818 (Div. 2)(A-E)
    java上传文件到指定服务器
    Qt ： 在QTreeWidget中添加自定义右键菜单
    安科瑞餐饮油烟监测云平台助力大气污染防治攻坚战
    力扣 430. 扁平化多级双向链表
    Sqoop
    AD9361寄存器功能笔记之本振频率设定
    【题型总结】找到第n个自定义数 | 丑数系列 + 神奇数字
  • 原文地址：https://blog.csdn.net/weixin_45483328/article/details/125472801