android中handler的理解

如何理解handler处理多线程问题。

多线程问题，简单来说就是， activity运行在并且已经运行在了ui thread。如果我们有个耗时的工作（比如文件读取，从网络下载数据等等工作），我们不能让这个耗时的工作直接在ui thread中调用，而是通过开一个work thread， 在work thread中完成耗时工作。

工作流程类似：

在ui thread中运行，有个耗时工作，开work thread，让这个耗时工作在work thread中运行。问题来了，这时候，ui thread和work thread各玩各的，然后 work thread工作完成了，我们就要通知 ui thread耗时工作结束了，ui thread需要处理结果了。

work thread如何通知ui thread，然后让ui thread继续处理？？？？

 

先看下ui thread的运行机制：

ui thread的运行就是一个无限的循环，在循环体内，取一个message，处理message，进入下一个循环。

 public static void loop() {
        final Looper me = myLooper();
       
        final MessageQueue queue = me.mQueue;

      
        for (;;) {

            Message msg = queue.next(); 
           
            //target 就是handler
            msg.target.dispatchMessage(msg);
               

            //这个很有意思，Message有个静态全局的Message链表，里面包含了一些闲置可用的Message对象。
            //如果需要一个message，先判断下这个链表是否包含对象，有的话，
            //从链表头取一个出来，返回给外面使用，否则就new 一个新的 message对象。
            //返回出去的那个message，就是在下面这一行回收到链表中。
            //所以，这个静态链表开始为空， 都是我们后面new的message在回收的时候不是简单的丢弃，而是放到这个静态链表中，给以后复用。
            msg.recycleUnchecked();
        }
    }

那么work thread通知ui thread就很容易了，只要work thread能够得到ui thread的消息队列 queue，在work thread中创建一个message对象，然后把这个message对象存入到ui thread的消息队列中。这样，ui thread在下次消息循环就可以得到这个message，然后就可以处理这个message了。

关键点：我们要把ui thread的 message queue传入到work thread。

这里需要谈点设计，如果赤裸裸的吧queue传入work thread中，实在没有美感，我们需要封装下，handler就是这个封装。2个thread之间就是通过handler来沟通。

在ui thread，我们需要构造一个handler（我们是要把ui thread的queue传入work thread，所以这个handle必须在ui thread中创建）。在ui thread中new一个handler出来，当前线程的looper和queue就会自动存入handler里面。然后把这个handler传入到work thread中，完成。

public class Handler {

    //成员变量，
    final Looper mLooper; 
    final MessageQueue mQueue; //和mLooper是一体的。

    //处理消息函数，提供了3个途径来处理message，我们只需要
    //改写3处中一个就可以，当然有先后顺序，如果你实现的第一个途径，后面2个途径的代码就不会执行，以此类推。这个Callback是排第二的处理方法。
    final Callback mCallback;


public Handler(Callback callback, boolean async) {
        
        //获取当前线程的looper。
        mLooper = Looper.myLooper();
        //这个queue就是从上面这个mLooper得到，
        // 是不是可以认为，不用定义这个mQueue，要用的时候，之间通过mLooper得到？？？？？
        mQueue = mLooper.mQueue;

        mCallback = callback;
       
    }

}

===

再看下消息的定义：

public final class Message implements Parcelable {


    public int what;

    //这个target就是我们在ui thread中定义的handler，
    //我们在handler类里面创建一个message的时候，把handler自己付给target。

    /*package*/ Handler target; 

    /*package*/ Runnable callback;

}

=======

消息的处理： 在looper中，我们看到消息处理的下面这行代码

         msg.target.dispatchMessage(msg);  // 这个target就是handler

public class Handler {

// handler 处理message的逻辑，可以看到有3个处理方法，前一个没处理，就给下一个处理。

public void dispatchMessage(Message msg) {

       //1， 先看下msg自己是不是带了callback处理函数，如果有，就用message自己处理函数处理。
       // 可以看出，创建message可以定义第一优先级的处理函数。
       // 当我们用 handler.post(  callback )来调用的时候，这个callback就是给message的成员变量
        if (msg.callback != null) {
            handleCallback(msg);

        } else {

            //2， handler自己带的callback函数，这个是创建handler的构造函数里面传入的，
            //好像大家都不设置这个。
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    //这个函数如果返回true，下面第3个消息处理逻辑就不执行了。
                    //所以，我们可以通过这个返回值来决定是否需要下面继续处理这个消息。
                    return;
                }
            }

            //3， 我们需要override handler的成员函数，我们定义handler的时候，会重写这个函数。
            // 这也是很多例子中告诉大家处理消息地方。 这个地方的优先级最低了。
            handleMessage(msg);
        }
    }


}

最后，2个work thread同样可以通过上面这个方法来互相协调工作。但是我们自己写的work thread是不启动 looper循环的。（ui thread本身就会启动looper，这个是系统运行了）

work thread启动looper代码：

public void run() {
        if(Looper.myLooper() == null)
        {
            Looper.prepare();
        }

        Looper.loop();
}