《提高能力，涨薪可待》-Java多线程与并发之ThreadLocal

时间 2020-01-10

标签提高能力，涨薪可待 java 多线程并发 threadlocal 栏目 Java 繁體版

原文原文链接

欢迎关注公众号【 Ccww笔记】，原创技术文章第一时间推出

往期文章：java

1. ThreadLocal是什么？使用场景

ThreadLocal简介

ThreadLocal是线程本地变量，能够为多线程的并发问题提供一种解决方式，当使用ThreadLocal维护变量时，ThreadLocal为每一个使用该变量的线程提供独立的变量副本，因此每个线程均可以独立地改变本身的副本，而不会影响其它线程所对应的副本。面试

ThreadLocal使用场景

多个线程去获取一个共享变量时，要求获取的是这个变量的初始值的副本。每一个线程存储这个变量的副本，对这个变量副本的改变不去影响变量自己。适用于多个线程依赖不一样变量值完成操做的场景。好比：spring

多数据源的切换
spring声明式事务

2. ThreadLocal的使用案例

ThreadLocal类接口：segmentfault

void set(T value)：设置当前线程的线程局部变量的值
T get()：获取当前线程所对应的线程局部变量
void remove()：删除当前线程局部变量的值，目的是为了减小内存的占用
T initialValue()：该线程局部变量的初始值(默认值为null)，该方法是一个protected的懒加载方法，线程第1次调用get()或set(T value)时才执行在，并且也是为了让子类覆盖而设计的。

public class ThreadLocalDemo {
    private static ThreadLocal<Index> index = new ThreadLocal(){
        @Override
        protected Object initialValue() {
            return new Index();
        }
    };

    private static class Index{
        private int num;

        public void incr(){
            num++;
        }
    }

    public static void main(String[] args) {
        for(int i=0; i<5; i++){
            new Thread(() ->{
                Index local = index.get();
                local.incr();
                System.out.println(Thread.currentThread().getName() + " " + index.get().num);
            }, "thread_" + i).start();
        }
    }
}

输出结果：数组

thread_1 1
thread_0 1
thread_3 1
thread_4 1
thread_2 1

能够看到每一个线程的获取的初始值都是0，而且对num++的操做也互不影响安全

3.ThreadLocal如何实现的

3.1 ThreadLocal的数据结构

ThreadLocal内部维护的是一个相似Map的ThreadLocalMap数据结构，而每一个Thread类，都有一个ThreadLocalMap成员变量。ThreadLocalMap将线程本地变量（ThreadLocal）做为key，线程变量的副本做为value，如图所示：
数据结构

须要注意的是ThreadLocal中的Entry的key和value的关系有系统进行维护，若维护不当则可能致使多线程状态下的不安全（通常不会，至少须要注意）。

3.2 get()源码分析

public T get() {
          //获取当前线程
          Thread t = Thread.currentThread();
          //获取当前线程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null) {
              //若是ThreadLocalMap已经被建立了，那么经过当前的threadLocal对象做为key，获取value
              ThreadLocalMap.Entry e = map.getEntry(this);
              if (e != null) {
                  @SuppressWarnings("unchecked")
                  T result = (T)e.value;
                  return result;
              }
          }
          //若是ThreadLocalMap尚未被建立或者在ThreadLocalMap中查找不到此元素
          return setInitialValue();
      }

3.2.1 ThreadLocalMap没初始化

ThreadLocalMap没初始化，ThreadLocalMap为null时，会调用setInitialValue()方法:多线程

private T setInitialValue() {
          //initialValue方法通常会被重写，不重写的话，直接返回null
          T value = initialValue();
          Thread t = Thread.currentThread();
          //获取当前线程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null)
              //ThreadLocalMap已经被建立，那么直接设置初始值（即保存变量副本），初始值来自initialValue方法
              map.set(this, value);
          else
              //建立ThreadLocalMap
              createMap(t, value);
          return value;
      }

其中，initialValue()方法是由咱们重写的，须要注意的是，返回值必须为new一个对象，而不是直接返回一个对象引用。由于若是多个线程都保存同一个引用的副本的话，那他们经过这个引用修改共享变量的值，是相互影响的。咱们原本的目的即是为了获取共享变量的初始值副本，各个线程对副本的修改不影响变量自己。

再来看看createMap是如何建立threadLocalMap的并发

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

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
             //建立一个初始容量为16的Entry数组
              table = new Entry[INITIAL_CAPACITY];
              //经过threadLocal的threadLocalHashCode来定位在数组中的位置
              int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
              //保存在数组中
              table[i] = new Entry(firstKey, firstValue);
              //记录下已用的大小
              size = 1;
              //设置阈值为容量的2/3
              setThreshold(INITIAL_CAPACITY);
          }

3.2.2 初始化threadLocalMap

初始化threadLocalMap以后，此线程再次调用get()方法，又作了哪些操做呢ide

public T get() {
          //获取当前线程
          Thread t = Thread.currentThread();
          //获取当前线程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null) {
              //若是ThreadLocalMap已经被建立了，那么经过当前的threadLocal对象做为key，获取value
              ThreadLocalMap.Entry e = map.getEntry(this);
              if (e != null) {
                  @SuppressWarnings("unchecked")
                  T result = (T)e.value;
                  return result;
              }
          }
          //若是ThreadLocalMap尚未被建立或者在ThreadLocalMap中查找不到此元素
          return setInitialValue();
      }

能够看到是经过map.getEntry(this)去查找元素的

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
                  //若是定位的元素的key与传入的key不相等，那么一直日后找
                  return getEntryAfterMiss(key, i, e);
          }

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)
                      //将过时的key清除掉，并把后面的元素（移动过位置的）往前移
                      expungeStaleEntry(i);
                  else
                      //日后移一位
                      i = nextIndex(i, len);
                  e = tab[i];
              }
              return null;
          }

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

private int expungeStaleEntry(int staleSlot) {
      Entry[] tab = table;
      int len = tab.length;
  
      // 清除当前元素
      tab[staleSlot].value = null;
      tab[staleSlot] = null;
      size--;
  
      //将此元素后面的，由于hash冲突移动过位置的元素往前移
      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);
              //h != i说明有过hash冲突
              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;
  }

若是map.getEntry(this)也找不到元素怎么办？

public T get() {
          //获取当前线程
          Thread t = Thread.currentThread();
          //获取当前线程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null) {
              //若是ThreadLocalMap已经被建立了，那么经过当前的threadLocal对象做为key，获取value
              ThreadLocalMap.Entry e = map.getEntry(this);
              if (e != null) {
                  @SuppressWarnings("unchecked")
                  T result = (T)e.value;
                  return result;
              }
          }
          //若是ThreadLocalMap尚未被建立或者在ThreadLocalMap中查找不到此元素
          return setInitialValue();
      }

那么继续调用setInitialValue()方法

private T setInitialValue() {
          //initialValue方法通常会被重写，不重写的话，直接返回null
          T value = initialValue();
          Thread t = Thread.currentThread();
          //获取当前线程的ThreadLocalMap
          ThreadLocalMap map = getMap(t);
          if (map != null)
              //ThreadLocalMap已经被建立，那么直接设置初始值（即保存变量副本），初始值来自initialValue方法
              map.set(this, value);
          else
              //建立ThreadLocalMap
              createMap(t, value);
          return value;
      }

能够看到将会调用它里面的map.set(this, 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;
                  }
  
                  if (k == null) {
                      //替代过时的元素，并清除后面的一些过时元素
                      replaceStaleEntry(key, value, i);
                      return;
                  }
              }
              
              //若是在table中确实找不到，那么新建一个
              tab[i] = new Entry(key, value);
              int sz = ++size;
              if (!cleanSomeSlots(i, sz) && sz >= threshold)
                  //若是没有元素被清除，且超过阈值，那么扩容并从新hash定位
                  rehash();
          }

3.3 set()源码分析

在看看set()方式处理与setInitialValue相似，少了获取初始化值，其余都相同，可参考get()方式中ThreadLocalMap没初始化方式:

public void set(T value) {
    //获取当前线程
    Thread t = Thread.currentThread();
    //获取当前线程的ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

3.4 总结

首先判断当前线程的threadLocalMap是否存在，若不存在则建立一个。将ThreadLocal做为key，共享变量初始值的副本做为value，保存在threadLocalMap中
若threadLocalMap存在，那么将ThreadLocal做为key，经过hash散列定位在数组中的位置，查找value
若是在threadLocalMap中找不到（缘由：被删除了，或者此ThreaLocal没有加入到threadLocalMap，毕竟threadLocalMap能够存放多个threadLocal），那么将ThreadLocal做为key，共享变量初始值的副本做为value，保存在threadLocalMap中
在set的过程当中，若是当前位置有其余元素（即hash冲突），那么日后找，直到不存在其余元素。而且在set的过程当中会清除一些过时（key为null）的元素。最后将根据size大小，决定是否扩容，从新hash定位

各位看官还能够吗？喜欢的话，动动手指点个💗，点个关注呗！！谢谢支持！
欢迎关注公众号【Ccww笔记】，原创技术文章第一时间推出