Handler学习

刚开始学习Android的时候，知道异步线程无法更新UI，于是找了个能把更新的动作抛给UI线程的东西，这个东西就是Handler。

一开始就只会在主线程也就是UI线程new一个Handler，之后在各个子线程里面使用，并没想过一些原理的东西，其实需要学习的知识还有很多。

一、线程之间的同步

A. 子线程向主线程发送消息，我们一开始学习的都是这种比较简单方式。

1、主线程中new Handler，并实现handleMessage方法

2、子线程中获得主线程Handler的实例

3、子线程向主线程发消息sendMessage

B. 主线程向子线程发送消息：

#点击按钮向mThread线程发送消息
mStartBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ......
                mHandler.sendMessage(......);
            }
        });
        mThread.start();
......

    Thread mThread = new Thread(new Runnable() {
        @Override
        public void run() {
            Looper.prepare();
            #实例化Handler，实现handleMessage
            mHandler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    ......
                }
            };
            Looper.loop();
        }
    });

通过这个我们比较直观的看见相同和不同的地方：

相同的地方：A线程向B线程发送消息，A需要拿到B实例化的Handler对象

不同的地方：子线程多了下面两个东西：

Looper.prepare();
.......
Looper.loop();

其实说不同的地方，只是A类型我们实现的时候不需要写Looper，理论上主线程一样需要有Looper，那么很容易想到，Android已经给我们写好了，后面有具体讲。

二、Looper,Handler,Message

Looper：

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

    public static void prepare() {
        prepare(true);
    }

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

Looper在创建的时候会初始化一个MessageQueue，这个是用来存储Message的管道

    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;
......

        for (;;) {
            Message msg = queue.next(); // might block
......
            final long end;
            try {
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
......
        }
    }

在loop的时候会循环的从MessageQueue取Message，然后分发Message。msg.target其实就是Handler，于是Handler就可以获得数据并进行处理。

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

    private static void handleCallback(Message message) {
        message.callback.run();
    }

上面的还是比较有意思的，这里简单总结下：

1. msg.callback不为空，执行msg.callback.run
2. mCallback不为null,执行mCallback.handleMessage(msg)，可能会执行第3中情况
3. 最后可能会执行Handler本身的handleMessage(msg)方法。

一般的是3这种情况，1发生在使用Handler在异步线程中直接更新UI的情况。

    Thread mThread = new Thread(new Runnable() {
        @Override
        public void run() {
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    textView.setText("xxxx");
                }
            });

        }
    });

其实mHandler.post也是发送了一个消息，然后把Runnable传给Message并处理。

总结下：

Looper其实就是创建一个循环获取消息并发送Handler的类。

Message其实就是一个数据存储的类，用于传输数据。

Handler就是进行发送和处理消息的类。

这三个配合起来一起用，才能构建了handler线程之间传递数据的机制。

问题一：上面所说的需要Looper，Handler,Message配合使用才能完成这个工作，那么我写子线程向主线程时怎么没看到主线程的Looper呢？

这个我们可以去看下Activity的源码，其实在ActivityThread里面已经写好了这个东西，所有我们不需要写了。

public static void main(String[] args) {
        ......

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

        Looper.prepareMainLooper();

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

        ......
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

注意：写在Looper.loop();后面的代码是无法执行。