ThreadLocal的工作原理

概述

ThreadLocal是一个用来存储线程内部数据的类，什么意思呢？ThreadLocal 重点突出的是Local，也就是存储的这个数据只有对应的线程才能访问。其他的线程是访问不到。哪个线程存，就只能哪个线程取。那是怎么做到的呢？

• 以ThreadLocal对象为键，任意对象为值作为存储结构；
• 然后把这个key-value 结构存入到ThreadLocalMap的对象中；
• 而实际上每个线程对象都有一个同样类型的变量指向这个ThreadLocalMap对象，且是唯一的。
• 存取都是对这个map操作，这样就实现了线程内部存取的策略。

ThreadLocal工作类图.png

源码分析(JDK5)

从概述中我们能看出来，真正实现存储数据的是这个ThreadLocalMap,那这里先不分析其的实现，暂且把他先理解成HashMap，便于分析。

1. 我们从set(T value)开始分析

    public void set(T value) {
        Thread t = Thread.currentThread(); //1、获取此方法的调用者线程
        ThreadLocalMap map = getMap(t);    //2.获取与这个线程绑定的ThreadLocalMap对象
        if (map != null)                   //3.判断这个对象是否为空
            map.set(this, value);          //4.不为空，就存储这个键值对
        else
            createMap(t, value);           //5.为空，就去创建这个map对象并存储这个键值对
    }
   

   源码中可以看到对这个map对象进行了唯一性的操作，只有为空的时候才会去创建。

   那再来去看一下这个createMap(Thread t, T firstValue)和getMap(Thread t)

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

   把创建的这个对象赋值给了Thread对象的一个变量t.threadLocals

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

   实际上就是获取这个线程保存的map对象。再来看一眼这个threadLocals在Thread中的定义

   Thread中声明了ThreadLocalMap.png

2. 取值 get()

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) { // 不为空，就从map中取出这个threadLocal为key的entry对象
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue(); //当map为null时候，去初始化这个Map并返回null
    }
   

   如果你对Map了解，那么Entry的获取就不难了。这里姑且先这么认为ThreadLocalMap就是hashmap以便于理解。

3. 移除 remove()

    public void remove() {
        ThreadLocalMap m = getMap(Thread.currentThread()); //1.获得map
        if (m != null)           //2.map不为空，从map中移除
            m.remove(this);
    }
   

ThreadLocal工作原理可以简单的概况为：
每个线程都会唯一绑定一个ThreadLocalMap的对象，用TheadLocal作为这个map的键，来存取值。

用法

public class MyClass {

    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();

    public static void main(String args[]) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set(1);
                new A().get();
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                threadLocal.set(10);
                new A().get();
            }
        }).start();

    }

    static class A {
        public void get() {
            int data = threadLocal.get();
            System.out.println("A from" + Thread.currentThread().getName() + "  get data:" + data);
        }
    }

}

运行结果.png

总结

• ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了线程保持对象的方法和避免参数传递的方便的对象访问方式。

• 使用场景，在Android中的Looper的保存就是这个ThreadLocal的运用。

    // sThreadLocal.get() will return null unless you've called prepare().
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
  
    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }  
  
   /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static Looper myLooper() {
        return sThreadLocal.get();
    }
  

  将Looper这个对象保存在对应的线程中，这样保证了一个线程对应一个Looper。

• 那有关ThreadLocalMap内部是如何来存取数据的，关后更......