音视频开发（四十二）：Android消息机制ThreadLocal

一、ThreadLocal是什么

ThreadLocal 线程局部变量是一个泛型类，可以接受任何类型的对象，一般ThreadLocal的类型的变量是static类型的。

我们知道不同线程有自己的栈，但是内存资源在同一个进程是共享的，即不同线程可以访问同一个变量，这样就会有多线程同步问题。即一个线程修改了变量，另外一个线程再读，如果不加锁或者volatile，可能导致不同线程的获取的结果不一致。

想象下面一种场景：满足下面两个条件

一个对象中的一个变量，会在不同的方法中会使用，这个对象会在不同线程中调用。
这个变量不需要多线程同步，而是需要每个线程都一份独立的值，即是线程隔离的。

这是我们该如何设计呐？
可能我们首先想到的是通过Map的方式，Key来存储Thread（eg：ThreadId），Value来存储每个Thread中该变量的值。在对map的读写操作上加上同步锁，即可实现上面场景的需求。
但是这种方案由于加了锁，会带来一定的性能损耗，是否还有更好的方式来实现线程隔离呐？

今天分析的ThreadLocal就是为此而设计的，它适用于每个线程需要自己独立的实例且该实例需要在多个方法中被使用，也即变量在线程间隔离而在方法或类间共享的场景。

使用ThreadLocal修饰的变量，在每个线程内都有自己副本，且该副本只能在自己的线程使用，实现了线程隔离。

二、如何使用ThreadLocal

这一小节，我们通过一个简单测试代码来说明ThreadLocal使用和验证它的线程隔离的特性。

在一个类中定义ThreadLocal类型的变量，分别在不同的线程赋不同的值，然后输出看下不同线程之间是否有影响。

public class ExampleUnitTest {

    //定义两个不同类型的ThreadLocal
    private static ThreadLocal<String> sStrThreadlocal = new ThreadLocal<>();
    private static ThreadLocal<Integer> sIntegerThreadLocal = new ThreadLocal<>();
    @Test
    public void addition_isCorrect() {
        assertEquals(4, 2 + 2);
    }

    @Test
    public void testThreadLocal(){

        //在主线程给Threadlocal赋值，请取出输出

        sStrThreadlocal.set("aaa");
        String value = sStrThreadlocal.get();

        sIntegerThreadLocal.set(1);
        int intValue = sIntegerThreadLocal.get();
        System.out.println("111 curThreadId="+Thread.currentThread()+" strthreadLocalValue="+value
        +" intThreadLocalValue="+intValue);

        //创建两个线程，分别给ThreadLocal赋不同的值
        new Thread(new Runnable() {
            @Override
            public void run() {
                sStrThreadlocal.set("bbb");
                String value = sStrThreadlocal.get();

                sIntegerThreadLocal.set(2);
                int intValue = sIntegerThreadLocal.get();
                System.out.println("222 curThreadId="+Thread.currentThread()+" strthreadLocalValue="+value
                        +" intThreadLocalValue="+intValue);

            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                String value = sStrThreadlocal.get();

                Integer intValue = sIntegerThreadLocal.get();

                System.out.println("333 curThreadId="+Thread.currentThread()+" strthreadLocalValue="+value
                        +" intThreadLocalValue="+intValue);

            }
        }).start();

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //最后在输出下主线程的ThreadLocal值
        value = sStrThreadlocal.get();
        intValue = sIntegerThreadLocal.get();
        System.out.println("444 curThreadId="+Thread.currentThread()+" strthreadLocalValue="+value
                +" intThreadLocalValue="+intValue);

    }
}

运行结果如下：

111 curThreadId=Thread[main,5,main] strthreadLocalValue=aaa intThreadLocalValue=1
222 curThreadId=Thread[Thread-0,5,main] strthreadLocalValue=bbb intThreadLocalValue=2
333 curThreadId=Thread[Thread-1,5,main] strthreadLocalValue=null intThreadLocalValue=null
444 curThreadId=Thread[main,5,main] strthreadLocalValue=aaa intThreadLocalValue=1

不同线程给ThreadLocal修饰的变量赋不同的值，在每个线程得到的值不同的，的确实现了线程的隔离。

那么它是如何做到的呐？是否是通过HashMap来存储不同线程的value值呐？我们通过分析ThreadLocal源码来找下答案。

关注+私信我，领取2022最新最全学习提升资料，内容包括（C/C++，Linux，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）

三、ThreadLocal源码分析

ThreadLocal 是一个泛型类，可以接受任何类型的对象

正如上面的示例代码所示，一个线程内可以存在多个 ThreadLocal 对象，而ThreadLocal 内部维护了一个 Map ，满足这种需求。
但是这个 Map 不是直接使用的 HashMap ，而是 ThreadLocal 实现的一个叫做 ThreadLocalMap 的静态内部类

通过上面示例我们可以看到通过set方式给ThreadLocal设置数据，get方法获取数据，我们以此为入口来进行分析

ThreadLocal#set

    public void set(T value) {
        //获取调用方所在的线程
        Thread t = Thread.currentThread();
        //获取该线程的ThreadLocal的副本，这个getMap方法是关键
        ThreadLocalMap map = getMap(t);
        //如果该线程存在该ThreadLocal的副本，则存入到map中，key，否则创建
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

getMap

获取该线程的ThreadLocal的副本
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

来看下Thread类，发现threadLocals变量的类型是ThreadLocal.ThreadLocalMap,即ThreadLocal的一个静态内部类

每个Thread对象内部都维护了一个ThreadLocalMap, 其可以存放若干个ThreadLocal

public class Thread implements Runnable {
    ......
    //当前线程的ThreadLocalMap，主要存储该线程自身的ThreadLocal，本文主要讨论这个变量
    ThreadLocal.ThreadLocalMap threadLocals = null;
    //自父线程继承而来的ThreadLocalMap，主要用于父子线程间ThreadLocal变量的传递
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
    .....
}

再来看下ThreadLocal.ThreadLocalMap

   static class ThreadLocalMap {
        .......
        private ThreadLocal.ThreadLocalMap.Entry[] table;

ThreadLocal.ThreadLocalMap.Entry

Entry的key是ThreadLocal的弱引用，value是对应的线程中线程局部变量set的值。
我们知道弱引用在GC的时候会销毁该引用所包裹(引用)的对象，这个threadLocal作为key可能被销毁（如果没有强引用存在），如果key为空，则该entry会从table中删除

static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;

            Entry(ThreadLocal<?> var1, Object var2) {
                super(var1);
                this.value = var2;
            }
        }

从本质来讲，就是每个线程都维护了一个map，而这个map的key就是threadLocal，而值就是我们set的那个值

分析完了set链路，我们再来看下get链路

当我们在调用get()方法的时候，先获取当前线程，然后获取到当前线程的ThreadLocalMap对象，如果非空，那么取出ThreadLocal的value，否则进行初始化，初始化就是将initialValue的值set到ThreadLocal中。

public T get() {
        //先获取当前线程
        Thread t = Thread.currentThread();
        //获取到当前线程的ThreadLocalMap对象
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            //如果非空，那么取出ThreadLocal的value
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                T result = (T)e.value;
                return result;
            }
        }
        //否则进行初始化，初始化就是将initialValue的值set到ThreadLocal中
        return setInitialValue();
    }

四、消息机制中Looper中的ThreadLocal使用

在Android的Framework中很多地方都使用了ThreadLocal，比如Looper、Choreographer、ActivityThread、ContentProvide、ViewRootImpl、SQLiteDatabase等等，在调用链追踪方面也是可以使用。
我们来分析下每个线程的Looper保证独立，并且一个线程有且只有一个Looper的

public final class Looper {
    ......
    // sThreadLocal.get() 将会返回 null，直到调用了 prepare().
    // sThreadLocal是一个ThreadLocal的一个实例，其类型为Looper
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();


    final MessageQueue mQueue;
    ......
}

通过ThreadLocal的线程隔离保证每个线程的Looper是不同的，
通过sThreadLocal.get() != null的异常断言，保证了一个线程只能有一个Looper
//初始化，将当前线程初始化为循环器

private static void prepare(boolean quitAllowed) {
        //通过ThreadLocal的线程隔离 保证每个线程的Looper是不同的，
        //通过sThreadLocal.get() != null的异常断言，保证了一个线程只能有一个Looper
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

    /**
      * 返回调用该方法所在线程对应的Looper
      * 如果调用者的线程还没有和Looper关联（通过preprea），则返回空
     */
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

收获

通过对本篇的学习实践

了解了ThreadLocal的意义以及原理
ThreadLocal的使用场景，它适用于每个线程需要自己独立的实例且该实例需要在多个方法中被使用，也即变量在线程间隔离而在方法或类间共享的场景。
Android消息机制中通过ThreadLocal保证Looper的线程隔离，get是断言判断保证一个Thread只能有一个Looper。