ThreadLocal原理分析

ThreadLocal原理分析

概述

   在之前的文章中介绍过Android应用层的消息机制【点这里 】，里面简单的提了一句ThreadLocal的使用，今天抽空来研究下它的使用与原理。

   ThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其它线程来说无法获取到数据。可以简单的理解为一个银行里，每个人只能拿着自己的银行卡存/取出自己的钱，而不能存/取别人的钱。

   ThreadLocal真实并不是一个Thread，而是Thread的局部变量，在我的理解里应该把它命名为ThreadLocalVariable可能更容易让人理解一些。

   Andorid引入ThreadLocal的初衷是为了提供线程内的局部变量，而不是为了解决共享对象的多线程访问问题，实际上，ThreadLocal根本就不能解决共享对象的多线程访问问题.

ThreadLocal的使用

   ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问(通过get或set方法访问)时能保证各个线程里的变量相对独立于其他线程内的变量。

   简单的实现如下：

public class demo15 {
    private final ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) {
        demo15 demo15 = new demo15();
        demo15.run();
    }

    public void run() {
        // 1
        threadLocal.set("hello threadlocal");
        new Thread("Thread#1") {
            @Override
            public void run() {
                // 2
                threadLocal.set("hello, " + this.getName());
                System.out.println("[Thread#1]threadLocal=" + threadLocal.get());
            };
        }.start();
        new Thread("Thread#2") {
            @Override
            public void run() {
                // 3
                System.out.println("[Thread#2]threadLocal=" + threadLocal.get());
            };
        }.start();
        // 4
        System.out.println(Thread.currentThread().getName() + "threadLocal=" + threadLocal.get());
    }
}

   其运行结果如下：

   结合运行结果分析：

• 代码1处给主线程设置了ThreadLocal值；
• 代码2处创建了新的线程Thread#1，并且对ThreadLocal设置了值，且取出的值也一致；
• 代码3处创建了另外一个新线程Thread#2，但未设置ThreadLocal值，此时取出的值为空；
• 代码4处取出了主线程的ThreadLocal值，与代码1处设置的值一致；

   以上可以总结，ThreadLocal未设置值的线程，取出的值为null；ThreadLocal中的set/get方法只与当前线程有关系，不影响其他线程。

   ThreadLocal的用法其实还是蛮简单的，Android结合其特性在很多源码内应用了ThreadLocal，如：

• Handler机制与HandlerThread机制
• SQLiteDatabase内部
• ActivityThread
• AMS内部
• …

   关于以上这些机制内部的ThreadLocal使用，这里不在赘述，有兴趣的可以去研究下。

ThreadLocal的源码分析

   查看ThreadLocal源码可以看到，其内部的实现方法并不多，JDK 1.8以前，仅set()、get()和remove()三个接口；JDK 1.8以来，多提供了一个withInitial()接口。这些接口其实就是针对线程中ThreadLocalMap的增删改查操作。但其内部维护了一个ThreadLocalMap数据结构，下面我们一一看下他们的实现。

set()

   set()方法的作用是往当前线程中设置“本地变量”，最终的结果是将变量设置到了线程内部的映射表。

    public void set(T value) {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 获取线程中的映射表
        ThreadLocalMap map = getMap(t);
        if (map != null)
            // 设置映射表的Key-Value，Key就是当前ThreadLocal对象
            map.set(this, value);
        else
            // 没有映射就创建新映射表
            createMap(t, value);
    }

  ThreadLocalMap getMap(Thread t) {
      // Thread内部维护的映射表对象
      return t.threadLocals;
  }

get()

   get()方法的作用是从当前线程中取出“本地变量”，最终的结果是在当前线程的映射表中，以调用get()方法的ThreadLocal对象为Key，查询出对应的Value。

    public T get() {
        // 获取当前线程
        Thread t = Thread.currentThread();
        // 获取线程中的映射表
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 获取映射表中当前ThreadLocal对应的Value
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        // 如果Map还未初始化或者Map中没有找到Key，则设置一个初始值
        return setInitialValue();
    }
    private T setInitialValue() {
       // 获取初始值，这个方法通常由ThreadLocal的泛型实例化类去实现
       T value = initialValue();
       Thread t = Thread.currentThread();
       ThreadLocalMap map = getMap(t);
       if (map != null)
           map.set(this, value);
       else
           createMap(t, value);
       return value;
   }

remove()

   remove()方法的作用就是删除当前线程中的“本地变量”，最终的结果是在当前线程的映射表中，通过Key移除对应的Value。

     public void remove() {
         // 获取线程中的映射表
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             //从映射表中删除键值
             m.remove(this);
     }

withInitial()

   withInitial()方法的作用是提供了一个Lambda构造方式，能够优雅的创建ThreadLocal对象。

    public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> var0) {
        //传入的Supplier对象，创建ThreadLocal对象
        return new ThreadLocal.SuppliedThreadLocal(var0);
    }
    static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
    private final Supplier<? extends T> supplier;

    SuppliedThreadLocal(Supplier<? extends T> var1) {
        this.supplier = (Supplier)Objects.requireNonNull(var1);
    }

    protected T initialValue() {
        return this.supplier.get();
    }
    }
//使用如下
private ThreadLocal<Integer> number = ThreadLocal.withInitial(() -> 1000);

ThreadLocalMap映射表

   从上面的分析可以看出，ThreadLocal操作的“本地变量”其实不是存储在ThreadLocal内部的，而是存储在各自线程内的映射表ThreadLocalMap中。而映射表的结构它是一个名为table的数组，每一个元素都是Entry对象，而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;
            }
        }

   ThreadLocalMap的Entry是WeakReference的子类，这样能保证线程中的映射表的每一个Entry可以被垃圾回收，而不至于发生内存泄露。因为ThreadLocal作为全局的Key，其生命周期很可能比一个线程要长，如果Entry是一个强引用，那么线程对象就一直持有ThreadLocal的引用，而不能被释放。随着线程越来越多，这些不能被释放的内存也就越来越多。

   ThreadLocal作为映射表的Key，需要具备唯一的标识，每创建一个新的ThreadLocal，这个标识就变的跟之前不一样了。 如何保证每一个ThreadLocal的唯一性呢？

public class ThreadLocal<T> {
    private static final int HASH_INCREMENT = 0x61c88647;
    // 每一个ThreadLocal对象的HashCode都不一样
    private final int threadLocalHashCode = nextHashCode();
    private static int nextHashCode() {
        // 下一个HashCode，是在已有基础上增加0x61c88647
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }
}

   ThreadLocal内部有一个名为threadLocalHashCode的变量，每创建一个新的ThreadLocal对象，这个变量的值就会增加0x61c88647。 正是因为有这么一个神奇的数字，它能够保证生成的Hash值可以均匀的分布在0~(2^N-1)之间，N是数组长度，从而保证唯一性。

   总结，ThreadLocal从原理上来看，其实就是一种优化后的数据存储结构，但却有其独特的特性，值得我们深入学习。

参考文献

【1】Java ThreadLocal的演化、实现和场景