前言

ThreadLocal的文章在网上也有不少，但是看了一些后，理解起来总感觉有绕，而且看了ThreadLocal的源码，无论是线程隔离、类环形数组、弱引用结构等等，实在是太有意思了！我必须也要让大家全面感受下其中所蕴含的那些奇思妙想！ 所以这里我想写一篇超几儿通俗易懂解析ThreadLocal的文章，相关流程会使用大量图示解析，以证明：我是干货，不是水比！

ThreadLocal这个类加上庞大的注释，总共也才七百多行，而且你把这个类的代码拷贝出来，你会发现，它几乎没有报错！耦合度极低！（唯一的报错是因为ThreadLocal类引用了Thread类里的一个包内可见变量，所以把代码复制出来，这个变量访问就报错了，仅仅只有此处报错！）

ThreadLocal的线程数据隔离，替换算法，擦除算法，都是有必要去了解了解，仅仅少量的代码，却能实现如此精妙的功能，让我们来体会下 Josh Bloch 和 Doug Lea 俩位大神，巧夺天工之作吧！

一些说明

这篇文章画了不少图，大概画了十八张图，关于替换算法和擦除算法，这俩个方法所做的事情，如果不画图，光用文字描述的话，十分的抽象且很难理解；希望这些流程图，能让大家更能体会这些精炼代码的魅力！

使用

哔哔原理之前，必须要先来看下使用

• 
  
• 使用起来出奇的简单，仅仅使用set()和get()方法即可
  

public class Main {

public static void main(String[] args) {

        ThreadLocal<String> threadLocalOne = new ThreadLocal<>();

        ThreadLocal<String> threadLocalTwo = new ThreadLocal<>();

new Thread(new Runnable() {
@Override
public void run() {

                threadLocalOne.set("线程一的数据 --- threadLocalOne");

                threadLocalTwo.set("线程一的数据 --- threadLocalTwo");

                System.out.println(threadLocalOne.get());

                System.out.println(threadLocalTwo.get());

            }

        }).start();

new Thread(new Runnable() {
@Override
public void run() {

                System.out.println(threadLocalOne.get());

                System.out.println(threadLocalTwo.get());

                threadLocalOne.set("线程二的数据 --- threadLocalOne");

                threadLocalTwo.set("线程二的数据 --- threadLocalTwo");

                System.out.println(threadLocalOne.get());

                System.out.println(threadLocalTwo.get());

            }

        }).start();

    }

}

• 
  
• 打印结果
  
  • 
    
  • 一般来说，我们在主存（或称工作线程）创建一个变量；在子线程中修改了该变量数据，子线程结束的时候，会将修改的数据同步到主存的该变量上
    
  • 但是，在此处，可以发现，俩个线程都使用同一个变量，但是在线程一里面设置的数据，完全没影响到线程二
    
  • cool！简单易用，还实现了数据隔离与不同的线程
    
  
  

线程一的数据 --- threadLocalOne

线程一的数据 --- threadLocalTwo
null
null

线程二的数据 --- threadLocalOne

线程二的数据 --- threadLocalTwo

前置知识

在解释ThreadLocal整体逻辑前，需要先了解几个前置知识

下面这些前置知识，是在说set和get前，必须要先了解的知识点，了解下面这些知识点，才能更好去了解整个存取流程

线程隔离

在上面的ThreadLocal的使用中，我们发现一个很有趣的事情，ThreadLocal在不同的线程，好像能够存储不同的数据：就好像ThreadLocal本身具有存储功能，到了不同线程，能够生成不同的'副本'存储数据一样

实际上，ThreadLocal到底是怎么做到的呢？

• 
  
• 来看下set()方法，看看到底怎么存数据的：此处涉及到ThreadLocalMap类型，暂且把他当成Map，详细的后面栏目分析
  
  • 
    
  • 其实这地方做了一个很有意思的操作：线程数据隔离的操作，是Thread类和ThreadLocal类相互配合做到的
    
  • 在下面的代码中可以看出来，在塞数据的时候，会获取执行该操作的当前线程
    
  • 拿到当前线程，取到threadLocals变量，然后仿佛以当前实例为key，数据value的形式往这个map里面塞值（有区别，set栏目再详细说）
    
  • 所以使用ThreadLocal在不同的线程中进行写操作，实际上数据都是绑定在当前线程的实例上，ThreadLocal只负责读写操作，并不负责保存数据，这就解释了，为什么ThreadLocal的set数据，只在操作的线程中有用
    
  • 大家有没有感觉这种思路有些巧妙！
    
  
  

//存数据
public void set(T value) {

    Thread t = Thread.currentThread();

    ThreadLocal.ThreadLocalMap map = getMap(t);
if (map != null)

        map.set(this, value);
else

        createMap(t, value);

}

//获取当前Thread的threadLocals变量

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

}

//Thread类
public class Thread implements Runnable {

    ...

/* ThreadLocal values pertaining to this thread. This map is maintained

     * by the ThreadLocal class. */

    ThreadLocal.ThreadLocalMap threadLocals = null;


    ...

}

• 
  
• 来看下图示
  
  • 
    
  • 图上只花了了一个ThreadLocal，想多花几个，然后线交叉了，晕
    
  • threadLocals是可以存储多个ThreadLocal，多个存取流程同理如下
    
  
  

• 
  
• 总结下：通过上面的很简单的代码，就实现了线程的数据隔离，也能得到几点结论
  
  • 
    
  • ThreadLocal对象本身是不储存数据的，它本身的职能是执行相关的set、get之类的操作
    
  • 当前线程的实例，负责存储ThreadLocal的set操作传入的数据，其数据和当前线程的实例绑定
    
  • 一个ThreadLocal实例，在一个线程中只能储存一类数据，后期的set操作，会覆盖之前set的数据
    
  • 线程中threadLocals是数组结构，能储存多个不同ThreadLocal实例set的数据
    
  
  

Entry

• 
  
• 说到Entry，需要先知道下四大引用的基础知识
  

强引用：不管内存多么紧张，gc永不回收强引用的对象

软引用：当内存不足，gc对软引用对象进行回收

弱引用：gc发现弱引用，就会立刻回收弱引用对象

虚引用：在任何时候都可能被垃圾回收器回收

Entry就是一个实体类，这个实体类有俩个属性：key、value，key是就是咱们常说的的弱引用

当我们执行ThreadLocal的set操作，第一次则新建一个Entry或后续set则覆盖改Entry的value，塞到当前Thread的ThreadLocals变量中

• 
  
• 来看下Entry代码
  
  • 
    
  • 此处key取得是ThreadLocal自身的实例，可以看出来Entry持有的key属性，属于弱引用属性
    
  • value就是我们传入的数据：类型取决于我们定义的泛型
    
  
  

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

    Object value;


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

        value = v;

    }

}

• 
  
• Entry有个比较巧妙的结构，继承弱引用类，然后自身内部又定义了一个强引用属性，使得该类有一强一弱的属性
  
• 结构图
  

你可能会想，what？我用ThreadLocal来set一个数据，然后gc一下，我Entry里面key变量引用链就断开了？

• 
  
• 来试一下
  

public class Main {

public static void main(String[] args) {

        ThreadLocal<String> threadLocalOne = new ThreadLocal<>();

new Thread(new Runnable() {
@Override
public void run() {

                threadLocalOne.set("线程一的数据 --- threadLocalOne");

                System.gc();

                System.out.println(threadLocalOne.get());

            }

        }).start();

    }

}

• 
  
• 结果
  

线程一的数据 --- threadLocalOne

看来这里gc了个寂寞。。。

在这里，必须明确一个道理：gc回收弱引用对象，是先回收弱引用的对象，弱引用链自然断开；而不是先断开引用链，再回收对象。Entry里面key对ThreadLocal的引用是弱引用，但是threadLocalOne对ThreadLocal的引用是强引用啊，所以ThreadLocal这个对象是没法被回收的

• 
  
• 来看下上面代码真正的引用关系
  

• 
  
• 此处可以演示下，threadLocalOne对ThreadLocal的引用链断开，Entry里面key引用被gc回收的情况
  

public class Main {
static ThreadLocal<String> threadLocalOne = new ThreadLocal<>();

public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {

                threadLocalOne.set("线程一的数据 --- threadLocalOne");
try {

                    threadLocalOne = null;

                    System.gc();

//下面代码来自：https://blog.csdn.net/thewindkee/article/details/103726942

                    Thread t = Thread.currentThread();

                    Class<? extends Thread> clz = t.getClass();

                    Field field = clz.getDeclaredField("threadLocals");

                    field.setAccessible(true);

                    Object threadLocalMap = field.get(t);

                    Class<?> tlmClass = threadLocalMap.getClass();

                    Field tableField = tlmClass.getDeclaredField("table");

                    tableField.setAccessible(true);

                    Object[] arr = (Object[]) tableField.get(threadLocalMap);
for (Object o : arr) {
if (o == null) continue;

                        Class<?> entryClass = o.getClass();

                        Field valueField = entryClass.getDeclaredField("value");

                        Field referenceField = entryClass.getSuperclass().getSuperclass().getDeclaredField("referent");

                        valueField.setAccessible(true);

                        referenceField.setAccessible(true);

                        System.out.println(String.format("弱引用key:%s    值:%s", referenceField.get(o), valueField.get(o)));

                    }

                } catch (Exception e) { }

            }

        }).start();

    }

}

• 
  
• 结果
  
  • 
    
  • key为null了！上面有行代码：threadLocalOne = null，这个就是断开了对ThreadLocal对象的强引用
    
  • 大家如果有兴趣的话，可以把threadLocalOne = null去掉，再运行的话，会发现，key不会为空
    
  • 反射代码的功能就是取到Thread中threadLocals变量，循环取其中的Entry，打印Entry的key、value值
    
  
  

弱引用key:null    值:线程一的数据 --- threadLocalOne

弱引用key:java.lang.ThreadLocal@387567b2    值:java.lang.ref.SoftReference@2021fb3f

• 
  
• 总结
  
  • 
    
  • 大家心里可能会想，这变量一直持有强引用，key那个弱引用可有可无啊，而且子线程代码执行时间一般也不长
    
  • 其实不然，我们可以想想Android app里面的主线程，就是一个死循环，以事件为驱动，里面可以搞巨多巨难的逻辑，这个强引用的变量被赋其它值就很可能了
    
    • 
      
    • 如果key是强引用，那么这个Entry里面的ThreadLocal基本就很难被回收
      
    • key为弱引用，当ThreadLocal对象强引用链断开后，其很容易被回收了，相关清除算法，也能很容易清理key为null的Entry
      
    
    
  • 一个弱引用都能玩出这么多花样
    
  
  

ThreadLocalMap环形结构

• 
  
• 咱们来看下ThreadLocalMap代码
  
  • 
    
  • 先去掉一堆暂时没必要关注的代码
    
  • table就是ThreadLocalMap的主要结构了，数据都存在这个数组里面
    
  • 所以说，ThreadLocalMap的主体结构就是一个Entry类型的数组
    
  
  

public class ThreadLocal<T> {


    ...

static class ThreadLocalMap {

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

            Object value;


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

                value = v;

            }

        }

/**

         * The table, resized as necessary.

         * table.length MUST always be a power of two.

         */
private Entry[] table;


        ...

    }

}

• 
  
• 在此处你可能又有疑问了，这东西不就是一个数组吗？怎么和环形结构扯上关系了？
  

• 
  
• 数组正常情况下确实是下面的这种结构
  

• 
  
• 但是，ThreadLocalMap类里面，有个方法做了一个骚操作，看下代码
  

public class ThreadLocal<T> {


    ...

static class ThreadLocalMap {

        ...

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

        }


        ...

    }

}

• 
  
• 这个nextIndex方法，大家看懂了没？
  
  • 
    
  • 它的主要作用，就是将传入index值加一
    
  • 但是！当index值长度超过数组长度后，会直接返回0，又回到了数组头部，这就完成了一个环形结构
    
  
  

• 
  
• 总结
  
  • 
    
  • 这样做有个很大的好处，能够大大的节省内存的开销，能够充分的利用数组的空间
    
  • 取数据的时候会降低一些效率，时间置换空间
    
  
  

set

总流程

• 
  
• 塞数据的操作，来看下这个set操作的代码：下面的代码，逻辑还是很简单的
  
  1. 
     
  2. 获取当前线程实例
     
  3. 获取当前线程中的threadLocals实例
     
  4. threadLocals不为空执行塞值操作
     
  5. threadLocals为空，new一个ThreadLocalMap赋值给threadLocals，同时塞入一个Entry
     
  
  

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 getMap(Thread t) {
return t.threadLocals;

}

void createMap(Thread t, T firstValue) {

    t.threadLocals = new ThreadLocalMap(this, firstValue);

}


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

}

• 
  
• 需要注意的是，ThreadLocalMap生成Entry数组，设置了一个默认长度，默认为：16
  

 private static final int INITIAL_CAPACITY = 16;


ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {

    table = new Entry[INITIAL_CAPACITY];

    ...

}

• 
  
• 流程图
  

map.set

• 
  
• 上面说了一些细枝末节，现在来说说最重要的map.set(this, value) 方法
  

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

// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.


    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;

        }

    }


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

        rehash();

}

取哈希值

• 
  
• 上面代码有个计算哈希值的操作
  
  • 
    
  • 从key.threadLocalHashCode这行代码上来看，就好像将自身的实例计算hash值
    
  • 其实看了完整的代码，发现传入key，只不过是为了调用nextHashCode方法，用它来计算哈希值，并不是将当前ThreadLocal对象转化成hash值
    
  
  

public class ThreadLocal<T> {
private final int threadLocalHashCode = nextHashCode();

private static final int HASH_INCREMENT = 0x61c88647;

private static AtomicInteger nextHashCode = new AtomicInteger();

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

        ...
int i = key.threadLocalHashCode & (len-1);

        ...

    }

private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);

    }

}

• 
  
• 这地方用了一个原子类的操作，来看下getAndAdd() 方法的作用
  
  • 
    
  • 这就是个相加的功能，相加后返回原来的旧值，保证相加的操作是个原子性不可分割的操作
    
  
  

public class Main {
public static void main(String[] args) {

        AtomicInteger atomicInteger = new AtomicInteger();


        System.out.println(atomicInteger.getAndAdd(1));  //0

        System.out.println(atomicInteger.getAndAdd(1));  //1

        System.out.println(atomicInteger.getAndAdd(1));  //2

    }

}

• 
  
• HASH_INCREMENT = 0x61c88647，为什么偏偏将将0x61c88647这个十六进制相加呢，为什么不能是1，2，3，4，5，6呢？
  

该值的相加，符合斐波那契散列法，可以使得的低位的二进制数值分布的更加均匀，这样会减少在数组中产生hash冲突的次数

具体分析可查看：从 ThreadLocal 的实现看散列算法

等等大家有没有看到 threadLocalHashCode = nextHashCode()，nextHashCode()是获取下一个节点的方法啊，这是什么鬼？

难道每次使用key.threadLocalHashCode的时候，HashCode都会变？

• 
  
• 看下完整的赋值语句
  
  • 
    
  • 这是在初始化变量的时候，就直接定义赋值的
    
  • 说明实例化该类的时候，nextHashCode()获取一次HashCode之后，就不会再次获取了
    
  • 加上用的final修饰，仅能赋值一次
    
  • 所以threadLocalHashCode变量，在实例化ThreadLocal的时候，获取HashCode一次，该数值就定下来了，在该实例中就不会再变动了
    
  
  

public class ThreadLocal<T> {
private final int threadLocalHashCode = nextHashCode();

}

好像又发现一个问题！threadHashCode通过 nextHashCode() 获取HashCode，然后nextHashCode是使用AtomicInteger类型的 nextHashCode变量相加，这玩意每次实例化的时候不都会归零吗？

难道我们每次新的ThreadLocal实例获取HashCode的时候，都要从0开始相加？

• 
  
• 来看下完整代码
  
  • 
    
  • 大家看下AtomicInteger类型的nextHashCode变量，他的修饰关键字是static
    
  • 这说明该变量的数值，是和这个类绑定的，和这个类生成的实例无关，而且从始至终，只会实例化一次
    
  • 当不同的ThreadLocal实例调用nextHashCode，他的数值就会相加一次
    
  • 而且每个实例只能调用一次nextHashCode()方法，nextHashCode数值会很均匀的变化
    
  
  

public class ThreadLocal<T> {
private final int threadLocalHashCode = nextHashCode();

private static final int HASH_INCREMENT = 0x61c88647;

private static AtomicInteger nextHashCode = new AtomicInteger();

private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);

    }

}

总结

• 
  
• 通过寥寥数行的初始化，几个关键字，就能形成在不同实例中，都能稳步变化的HashCode数值
  
• 这些基础知识大家或许都知道，又有多少能这样信手拈来呢？