Java并发编程之ThreadLocal

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

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

效果：

可见线程间互不影响

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点击打开链接）

     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，如果找到了，把弱引用断了做一次段清理。

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