Java并发编程之ThreadLocal

港控/mmm° 2022-05-23 12:59 282阅读 0赞

> 微信公众号：`每天学Java`  
> 如有问题或建议，请公众号留言

![20180609131855503][]

### ThreadLocal简介 ###

ThreadLocal类的作用是为每个线程都创建一个变量副本, 每个线程都可以修改自己所拥有的变量副本, 而不会影响其他线程的副本. 其实这也是解决线程安全的问题的一种方法.

### ThreadLocal小例子 ###

那我们来写一个简单的程序来看一下效果：

public class ThreadLocalTest {
        private Thread thread;
        private ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>(){
            public Integer initialValue(){
                return 10;
            }
        };
        public void Thread1(){
            new Thread(new Runnable() {
                @Override public void run() {
                    threadLocal.set(1);
                    System.out.println("Thread1"+threadLocal.get());
                }
            }).start();
        }
        public void Thread2(){
            new Thread(new Runnable() {
                @Override public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Thread2"+threadLocal.get());
                }
            }).start();
        }
        public static void main(String[] args) {
            new ThreadLocalTest().Thread1();
            new ThreadLocalTest().Thread2();
        }
    }

效果：

![70][]

可见线程间互不影响

### ThreadLocal分析 ###

ThreadLocal 有这么几个方法  
get() set() remove() inittalValue()  
先看get方法

public T get() {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);//线程t的threadLocals。
            if (map != null) {
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            return setInitialValue();
        }

getMap()方法

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

Entry对象设置为弱引用：因为如果这里使用普通的key-value形式来定义存储结构，实质上就会造成节点的生命周期与线程强绑定，只要线程没有销毁，那么节点在GC分析中一直处于可达状态，没办法被回收，而程序本身也无法判断是否可以清理节点。弱引用是Java中四档引用的第三档，比软引用更加弱一些，如果一个对象没有强引用链可达，那么一般活不过下一次GC。当某个ThreadLocal已经没有强引用可达，则随着它被垃圾回收，在ThreadLocalMap里对应的Entry的键值会失效，这为ThreadLocalMap本身的垃圾清理提供了便利（https://www.cnblogs.com/micrari/p/6790229.html[点击打开链接][Link 1]）

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

这里我们先分析一下map==null或者map!=null但是Entry為null的情况  
如果map为null说明该线程的ThreadLocalMap对象为null；  
执行setInitialValue()

private T setInitialValue() {
            T value = initialValue();//初始是null，可以通过重写方法给初始值赋值
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);//map不为null，则将该ThreadLocal对象set进去
            else
                createMap(t, value);//map为null，new 一个ThreadLocalMap出来并将ThreadLocal对象存入，
            return value;
        }

set方法：

public void set(T value) {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                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);//位运算。这里可以百度一下len为什么总是偶数，里面需要说东西太多了，大家可以好好查阅看看
                for (Entry e = tab[i];
                     e != null;
                     e = tab[i = nextIndex(i, len)]) {
                    ThreadLocal<?> k = e.get();
                    if (k == key) {
       //key相同则替换value
                        e.value = value;
                        return;
                    }
    //和HashMap不一样，由于Entry key继承了软引用，会出现k是null的情况！所以会接着在replaceStaleEntry重新循环寻找相同的key
                    if (k == null) {
                        replaceStaleEntry(key, value, i);
                        return;
                    }
                }
                tab[i] = new Entry(key, value);//Entry[]在下标是i的位置，存入Entry对象
                int sz = ++size;
                if (!cleanSomeSlots(i, sz) && sz >= threshold)
                    rehash();
            }

createMap方法

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

remove方法：

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

remove方法相对于getEntry和set方法比较简单，直接在table中找key，如果找到了，把弱引用断了做一次段清理。

[20180609131855503]: /images/20220523/86d8c2de801145c49fdfe4c8f646bbdb.png
[70]: /images/20220523/435e80f948334fd988bcef1ecaa63ee4.png
[Link 1]: https://www.cnblogs.com/micrari/p/6790229.html