从Looper源码中，我们可以看出Looper在prepare()初始化过程中存储到ThreadLocal,如果我们想获取Looper对象，直接在对应线程中通过Looper.myLooper()方法获取；
 2.监听器的传递，有时候一个线程中的任务过于复杂，代码上表现为函数调用栈比较深获取代码入口多样性，在这种情况下，我们又需要监听器能够贯穿整个线程的执行过程，数据库连接管理，数据库事务。然后常见的方法就是:
  1.监听器通过参数的形式在函数调用栈中传递。调用栈过深会导致程序结构及其糟糕
  2.将监听器作为静态变量供线程访问，这种方式不具备扩展性，如果有两个线程同时执行，就必须提供两个静态的监听器对象，那如果有10个线程在并发执行？提供10个静态的监听器对象？

但是如果使用ThreadLocal，就可以让监听器作为线程内的全局对象，在线程内部只需要通过get方法就可以获取到监听器。例如下载操作中，我们监听文件的下载进度，我们需要在下载完以后进行压缩，那么在CompressManager中我们直接就可以获取OnDownloadListener对象，而不需要通过参数传递。

public class DownloadTask {
    static final ThreadLocal<OnDownloadListener> mThreadLocal = new ThreadLocal<>();
    OnDownloadListener mOnDownloadListener;
    public DownloadTask(OnDownloadListener onDownloadListener) {
        mOnDownloadListener = onDownloadListener;
        mThreadLocal.set(onDownloadListener);
    }
    public static OnDownloadListener getOnDownloadListener() {
        return mThreadLocal.get();
    }
    public void download() {
        //start download
        getOnDownloadListener().startDownload();
        //..... 

        //pause download
        getOnDownloadListener().pauseDownload();
        //cancel download
        getOnDownloadListener().cancelDownload();
    }
} 
   class CompressManager{
        void compress(){
            //compressing...
            //compress complete
            DownloadTask.getOnDownloadListener().downloadComplete();
        }
    }

小试牛刀

看了上面的应用场景，我们来使用下ThreadLocal，看看是否那么神奇

   ThreadLocal mThreadLocal = new ThreadLocal<>();
        mThreadLocal.set(true);
        new Thread(new Runnable() {
            @Override
            public void run() {
                mThreadLocal.set(false);
                Log.i("test","subThread1:"+mThreadLocal.get());
            }
        },"subThread1").start();
        new Thread("subThread2"){
            @Override
            public void run() {
                super.run();
                Log.i("test","subThread2:"+mThreadLocal.get());
            }
        }.start();
        Log.i("test","mainThread:"+mThreadLocal.get());

上面的代码中，我们先在主线程中设置为true，subThread1中设置为false,subThread2中不设置值，结果在不同的线程中访问的是同一个ThreadLocal对象，但是他们通过ThreadLocal获取的值却是不一样的。

内部实现

那么我们来看下ThreadLocal内部是怎么实现的？
其实只要弄清楚ThreadLocal中的get和set方法就可以明白他的工作原理。

public void set(T value) {
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values == null) {
            values = initializeValues(currentThread);
        }
        values.put(this, value);
    }
 public T get() {
        // Optimized for the fast path.
        Thread currentThread = Thread.currentThread();
        Values values = values(currentThread);
        if (values != null) {
            Object[] table = values.table;
            int index = hash & values.mask;
            if (this.reference == table[index]) {
                return (T) table[index + 1];
            }
        } else {
            values = initializeValues(currentThread);
        }
        return (T) values.getAfterMiss(this);
    }
  Values values(Thread current) {
        return current.localValues;
    }

从上面两个方法可以看出来，它们所操作的对象都是当前线程的localValues对象的table数组，因此在不同线程中访问同一个ThreadLocal的set和get方法，他们对ThreadLocal所做的读写操作都仅限于线程内部。