并发编程--ThreadLocal

ThreadLocal

---

ThreadLocal实际上一种线程隔离机制，为了保证在多线程环境下对于共享变量的访问的安全性。

static ThreadLocal local = new ThreadLocal(){
    protected Integer initialValue(){
        return 0; //初始化一个值
    } 
};
public static void main(String[] args) { 
    Thread[] thread = new Thread[5]; 
    for (int i = 0;i < 5;i++){ 
        thread[i] = new Thread(()->{
        int num = local.get(); //获得的值都是0 local.set(num+=5); //设置到local中 
        System.out.println(Thread.currentThread().getName()+"-"+num); }); 
    }
    for (int i = 0; i < 5; i++) {
        thread[i].start(); 
    } 
}

ThreadLocal原理分析

---

主要API有 get()、set()、remove(),下面主要分析set()方法，get()和remove()实现相对简单。

1.png

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

从ThreadLocalMap map = getMap(t);可以看到，线程内部维护了一个ThreadLocalMap,接下来我们去分析getMap(t)。

  /**
/* ThreadLocal values pertaining to this thread. This map is maintained by the ThreadLocal class. */
 ThreadLocal.ThreadLocalMap threadLocals = null;

 * Get the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param  t the current thread
 * @return the map
 */
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

getMap()操作就是返回ThreadLocal的一个 成员变量，换句话说就是这个ThreadLocalMap是线程私有的。因为第一次进来这个map是null，我们下一步是createMap(t, value);

/**
* Create the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param t the current thread
* @param firstValue value for the initial entry of the map
*/
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* Construct a new map initially containing (firstKey, firstValue).
* ThreadLocalMaps are constructed lazily, so we only create
* one when we have at least one entry to put in it.
*/
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);
}

上述源码可以清楚的看到:

• 我们会初始化一个大小为16的Entry数组，然后会生成一个数组下标，将数据放入。这里我们也可以猜想Entry的数据结构是key-value。
• 到这为止，我们已经初始化了一个entry数组，并且将我们要存放的值放入了entry中，key表示的是当前线程，value是存放的值（num），
• 看到这里，你可能会有疑问， int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);，生成的数组下标会不会出现重复，也就是我们常说的hash冲突,我们可以看一下他取的hash值是什么。
  
  5.png

    /**
     * ThreadLocals rely on per-thread linear-probe hash maps attached
     * to each thread (Thread.threadLocals and
     * inheritableThreadLocals).  The ThreadLocal objects act as keys,
     * searched via threadLocalHashCode.  This is a custom hash code
     * (useful only within ThreadLocalMaps) that eliminates collisions
     * in the common case where consecutively constructed ThreadLocals
     * are used by the same threads, while remaining well-behaved in
     * less common cases.
     */
    private final int threadLocalHashCode = nextHashCode();

    /**
     * Returns the next hash code.
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

    /**
     * 连续生成的散列码之间的差异
     * 隐式顺序线程将局部IDs转换为近似最优分布
     * 两个表的幂的乘法散列值。
     */
    private static final int HASH_INCREMENT = 0x61c88647;

我简单的翻译了一下，核心思想就是通过散列（斐波那契数列）的方式避免hash冲突，大家可以通过拿到这个hash值，自己测试一下他生成的值的分布。

public class HashDemo {

    private static final int HASH_INCREMENT = 0x61c88647;

    public static void main(String[] args) {
        magicHash(16);
        magicHash(32);
    }

    private  static void magicHash(int size){
        int hashCode=0;
        for(int i=0;i

上述代码运行的结果：

2.png

set方法最终实现

---

前面分析了set方法第一次初始化ThreadLocalMap的过程，也对ThreadLocalMap的结构有了一个全面的了解。那么接下来看一下map不为空时的执行逻辑

• 根据key的散列哈希计算Entry的数组下标
• 通过线性探索探测从i开始往后一直遍历到数组的最后一个Entry
• 如果map中的key和传入的key相等，表示该数据已经存在，直接覆盖
• 如果map中的key为空，则用新的key、value覆盖，并清理key=null的数据
• rehash扩容

private void set(ThreadLocal key, Object value) { 
    Entry[] tab = table; 
    int len = tab.length;
     // 根据哈希码和数组长度求元素放置的位置，即数组下标 
    int i = key.threadLocalHashCode & (len-1);
     //从i开始往后一直遍历到数组最后一个Entry(线性探索)
    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { 
        ThreadLocal k = e.get(); //如果key相等，覆盖value 
        if (k == key) {
            e.value = value;
            return; 
        }
        //如果key为null,用新key、value覆盖，同时清理历史key=null的陈旧数据(弱引用)
        if (k == null) { 
            replaceStaleEntry(key, value, i); return; 
        } 
    }
    tab[i] = new Entry(key, value);
    int sz = ++size;
     //如果超过阀值，就需要扩容了
    if (!cleanSomeSlots(i, sz) && sz >= threshold) 
        rehash(); 
}

• 线性探测，是用来解决hash冲突的一种策略。它是一种开放寻址策略

• 我想大家应该都知道hash表，它是根据key进行直接访问的数据结构，也就是说我们可以通过hash函数把key映射到hash表中的一个位置来访问记录，从而加快查找的速度。存放记录的数据就是hash表（散列表）

• 当我们针对一个key通过hash函数计算产生的一个位置，在hash表中已经被另外一个键值对占用时，那么线性探测就可以解决这个冲突，这里分两种情况。

• 写入： 查找hash表中离冲突单元最近的空闲单元，把新的键值插入到这个空闲单元

• 查找： 根据hash函数计算的一个位置处开始往后查找，指导找到与key对应的value或者找到空的单元。

replaceStaleEntry

---

接下来分析一下清理的过程和替换过程，这个过程比较有意思。从名字上来看，叫替换脏的不干净的Entry，我们来看是怎么实现的。

private void replaceStaleEntry(
    ThreadLocal key, Object value, int staleSlot) { 
    Entry[] tab = table; int len = tab.length; 
    Entry e; 
    //向前扫描，查找最前一个无效的slot 
    int slotToExpunge = staleSlot; 
    for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i,len)) {
        if (e.get() == null) {
            //通过循环遍历，可以定位到最前面一个无效的slot 
            slotToExpunge = i;
        }
    }
    //从i开始往后一直遍历到数组最后一个Entry（线性探索） 
    for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)){
         ThreadLocal k = e.get(); //找到匹配的key以后
         if (k == key) {
            e.value = value;//更新对应slot的value值
         //与无效的sloat进行交换 
        tab[i] = tab[staleSlot]; 
        tab[staleSlot] = e; 
        //如果最早的一个无效的slot和当前的staleSlot相等，则从i作为清理的起点 
        if (slotToExpunge == staleSlot) 
            slotToExpunge = i; 
        //从slotToExpunge开始做一次连续的清理       
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); 
        return;
    }
    //如果当前的slot已经无效，并且向前扫描过程中没有无效slot，则更新slotToExpunge为当 前位置
    if (k == null && slotToExpunge == staleSlot) 
        slotToExpunge = i; 
    }
    //如果key对应的value在entry中不存在，则直接放一个新的entry    
    tab[staleSlot].value = null; 
    tab[staleSlot] = new Entry(key, value); 
    //如果有任何一个无效的slot，则做一次清理 
    if (slotToExpunge != staleSlot) {
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
    } 
 }

线性探测

---

用来解决hash冲突的一种策略.

• 写入 , 找到发生冲突最近的空闲单元
• 查找, 从发生冲突的位置，往后查找