Android开发笔记1：Handler、Looper、ThreadLocal的那些事

Handler和Looper的关系

使用过Handler的同学都应该知道，Handler最重要的两个方法就是sendMessage等发消息的方法和handleMessage处理消息的方法，下面就看看线程间是怎么通过Handler进行通信的。

1、Handler的默认构造方法

从中可以看到初始化了成员变量mLooper = Looper.myLooper()，mQueue = mLooper.mQueue

其实就是Looper mLooper 和 MessageQueue mQueue，mQueue就是存放Message的消息队列，同时消息队列是保存在Looper中的，至于为什么要把消息队列保存在Looper中，我们之后会进行说明。

public Handler() {
        if (FIND_POTENTIAL_LEAKS) {
            final Class<? extends Handler> klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = null;
    }

2、发送消息

sendMessage等发送消息的方法最终都会执行下面的方法，我们看到其实就是把要发送的消息Message msg和对应的发送时间uptimeMillis放到消息队列mQueue中

public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        boolean sent = false;
        MessageQueue queue = mQueue;
        if (queue != null) {
            msg.target = this;
            sent = queue.enqueueMessage(msg, uptimeMillis);
        }
        else {
            RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
        }
        return sent;
    }

3、处理消息

那么什么时候才会处理这些发送的消息呢？没错接下来就是Looper登场了。

1）首先代码中初始化Looper me = myLooper();

这已经是第二次调用mLooper()来初始化了，所以这里多说一句，在使用myLooper()初始化前一定要调用Looper.prepare()来把Looper添加到sThreadLocal

  public static final void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

看到没，实际就是从sThreadLocal中取出来的，所以用之前一定得set啊

public static final Looper myLooper() {
        return (Looper)sThreadLocal.get();
    }

2）在loop方法中我们看到有一行msg.target.dispatchMessage(msg)，没错就是这里执行的。

 public static final void loop() {
        Looper me = myLooper();
        MessageQueue queue = me.mQueue;
        while (true) {
            Message msg = queue.next(); // might block
            //if (!me.mRun) {
            //    break;
            //}
            if (msg != null) {
                if (msg.target == null) {
                    // No target is a magic identifier for the quit message.
                    return;
                }
                if (me.mLogging!= null) me.mLogging.println(
                        ">>>>> Dispatching to " + msg.target + " "
                        + msg.callback + ": " + msg.what
                        );
                msg.target.dispatchMessage(msg);
                if (me.mLogging!= null) me.mLogging.println(
                        "<<<<< Finished to    " + msg.target + " "
                        + msg.callback);
                msg.recycle();
            }
        }
    }       

接着往下看，下面代码就会执行handleMessage来处理消息。并且如果你调用了Handler中的post(Runnable r)等方法，那么msg.callback != null 那么就会执行handleCallback(msg)

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

结论：处理消息必须要执行Looer.loop()，而执行Looper.loop()就需要先Looper.prepare()，那么为什么大多数时候我们并没有显示调用Looper.prepare() Looper.loop()呢？

主线程（ActivityThread）

1、首先看下main函数里做了什么

1）从下面的代码中可以看到，在主线程的main()方法中，调用了Looper.prepareMainLooper()和Looper.loop()

是不是很像之前讲的的Looper.prepare(),Looper.loop()?

public static final void main(String[] args) {
        SamplingProfilerIntegration.start();

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        Looper.loop();

        if (Process.supportsProcesses()) {
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }

        thread.detach();
        String name = (thread.mInitialApplication != null)
            ? thread.mInitialApplication.getPackageName()
            : "<unknown>";
        Slog.i(TAG, "Main thread of " + name + " is now exiting");
    }

2）看看prepareMainLooper()方法不难发现，原来这个方法中就调用了Looper.prepare()方法。

 public static final void prepareMainLooper() {
        prepare();
        setMainLooper(myLooper());
        if (Process.supportsProcesses()) {
            myLooper().mQueue.mQuitAllowed = false;
        }
    }

结论：主线程里我们并不需要显示调用，但是子线程中一定记得要显示调用Looper.prepare()和Looper.loop()

ThreadLocal

我们还记得在Looper.prepare()中调用过sThreadLocal.set(new Looper())，下面重贴下代码。

注意：每个线程只有一个Looper对象，因为每个Thread只有一个ThreadLocalMap对象并且都以key为ThreadLocal.this存储。那么在一个线程中实现多个Handler就没有意义了，因为他们都使用同一个Looper对象来保存消息。

 public static final void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

而set方法实际上就是通过当前线程获得ThreadLocalMap，并把Looper放到当前线程的ThreadLocalMap中，并以ThreadLocal.this为key。

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

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

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