对Handler中ThreadLocal的理解

插个查看源码的链接：https://cs.android.com/

目录

ThreadLocal是什么呢？

示例代码

Looper中使用

 

ThreadLocal源码解析：

ThreadLocal内存泄漏问题？

---

ThreadLocal 可以把一个对象保存在指定的线程中，对象保存后，只能在指定线程中获取保存的数据，对于其他线程来说则无法获取到数据。Android系统在 Handler 机制中使用了它来保证每一个 Handler 所在的线程中都有一个独立的 Looper 对象。

ThreadLocal是什么呢？

ThreadLocal 是一个关于创建线程局部变量的类。其实就是这个变量的作用域是线程，其他线程访问不了。通常我们创建的变量是可以被任何一个线程访问的，而使用 ThreadLocal 创建的变量只能被当前线程访问，其他线程无法访问。

示例代码

    private ThreadLocal<String> mThreadLocal = new ThreadLocal<>();
    private static final String TAG = "ThreadLocalTest";

    @Test
    public void test2() {
        mThreadLocal.set("main thread");
        Log.e(TAG, "main thread 's mThreadLocal = " + mThreadLocal.get());
        new Thread("thread 1"){
            @Override
            public void run() {
                super.run();
                Log.e(TAG, " thread 1 's mThreadLocal = " + mThreadLocal.get());
            }
        }.start();
    }

E/ThreadLocalTest: main thread 's mThreadLocal = main thread
E/ThreadLocalTest:  thread 1 's mThreadLocal = null

从以上示例代码可以看出，MainThread 对 stringThreadLocal 的修改并没有影响到 Thread 1 中的值。说明了使用 ThreadLocal 保存的对象的作用域是当前线程。

再来看看ThreadLocal在Looper中的应用

Looper中使用

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

在Android源码中，使用 ThreadLocal 保存 Looper，确保每个线程中只有一个 Looper 对象

 

ThreadLocal源码解析：

ThreadLocal的public方法只有set、get和setInitialValue三个方法，分别如下：

• set方法源码

    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

    /**
     * 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;
    }

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

set 方法进行了如下几部操作：

1.获取当前线程
2.使用当前线程获取一个 ThreadLocalMap 对象
3.如果获取到的 map 对象不为空，则设置值，否则创建 map 设置值

结论：原来每个线程都有一个保存值的 ThreadLocalMap 对象，ThreadLocal 的值就存放在了当前线程的 ThreadLocalMap 成员变量中，所以只能在本线程访问，其他线程不能访问。

具体的保存方法如下：

ThreadLocalMap#set()
        /**
         * Set the value associated with key.
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        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();
        }

上面的代码实现了数据的存储，其中 table 是一个 Entry[] 数组对象，而 Entry 是用来存储 ThreadLocal key, Object value 的，逻辑是根据 key 找出 Entry 对象，如果找出的这个 Entry 的 k 等于 key，直接设置 Entry 的 value，如果 k 为空，则通过 replaceStaleEntry 保存数据，最后构建出 Entry 保存进 table 数组中。

• get方法源码如下：

    /**
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

get 方法首先取出当前线程的 ThreadLocalMap 对象，如果这个对象为空，则返回默认值；如果不为空，使用当前 ThreadLoacl 对象(this)获取 ThreadLocalMap 的 Entry 对象，返回 Entry 保存的 value 值。

从 ThreadLoacl 的 set 和 get 方法来看，它们操作的对象都是当前线程对象中的 ThreadLocalMap 对象的 Entry[] 数组，因此在不同的线程中访问同一个 ThreadLoacl 的 set 和 get 方法，操作的对应线程中的数据，所以不会影响到其他线程。

ThreadLocal内存泄漏问题？

每个thread中都存在一个map, map的类型是ThreadLocal.ThreadLocalMap. Map中的key为一个threadlocal实例. 这个Map的确使用了弱引用,不过弱引用只是针对key. 每个key都弱引用指向threadlocal. 当把threadlocal实例置为null以后,没有任何强引用指向threadlocal实例,所以threadlocal将会被gc回收. 但是,我们的value却不能回收,因为存在一条从current thread连接过来的强引用. 只有当前thread结束以后, current thread就不会存在栈中,强引用断开, Current Thread, Map, value将全部被GC回收。所以得出一个结论就是只要这个线程对象被gc回收，就不会出现内存泄露，但在threadLocal设为null和线程结束这段时间不会被回收的，就发生了我们认为的内存泄露。其实这是一个对概念理解的不一致，也没什么好争论的。最要命的是线程对象不被回收的情况，这就发生了真正意义上的内存泄露。比如使用线程池的时候，线程结束是不会销毁的，会再次使用的就可能出现内存泄露 。（在web应用中，每次http请求都是一个线程，tomcat容器配置使用线程池时会出现内存泄漏问题）

 

参考链接：https://www.cnblogs.com/mingfeng002/p/11917883.html