Android消息处理机制——Looper,Handler,Message,MessageQueue,Thread

Android消息机制，通常我们也称为Handler机制，在实际开发中，我们通常使用Handler来控制主UI界面的变化，Handler的作用可以总结为：与其他线程协同工作，接收其他线程的消息并通过接收到的消息更新主UI线程的内容。

Message：消息，由MessageQueue统一列队，终由Handler处理。
Handler：处理者，负责Message的发送及处理。
MessageQueue：消息队列，用来存放Handler发送过来的消息。
Looper：消息泵，不断地从MessageQueue中抽取Message执行。一个线程中只有一个Looper实例。
Thread：线程，负责调度整个消息循环，即消息循环的执行场所。

消息处理总体流程：

在消息使用完毕后，在Looper.loop()方法中调用msg.recycle()，将消息进行回收，即将消息的所有字段恢复为初始状态。

源码解析

Looper

对于Looper主要是prepare()和loop()两个方法。
首先看prepare()方法：

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

sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量。可以看到，在第5行，将一个Looper的实例放入了ThreadLocal，并且2-4行判断了sThreadLocal是否为null，否则抛出异常。这也就说明了Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例。

Looper的构造方法：

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

在构造方法中，创建了一个MessageQueue（消息队列）。

然后我们看loop()方法：

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;        // Make sure the identity of this thread is that of the local process,        // and keep track of what that identity token actually is.        Binder.clearCallingIdentity();        final long ident = Binder.clearCallingIdentity();        for (;;) {            Message msg = queue.next(); // might block            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }            // This must be in a local variable, in case a UI event sets the logger            Printer logging = me.mLogging;            if (logging != null) {                logging.println(">>>>> Dispatching to " + msg.target + " " +                        msg.callback + ": " + msg.what);            }            msg.target.dispatchMessage(msg);            if (logging != null) {                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);            }            // Make sure that during the course of dispatching the            // identity of the thread wasn't corrupted.            final long newIdent = Binder.clearCallingIdentity();            if (ident != newIdent) {                Log.wtf(TAG, "Thread identity changed from 0x"                        + Long.toHexString(ident) + " to 0x"                        + Long.toHexString(newIdent) + " while dispatching to "                        + msg.target.getClass().getName() + " "                        + msg.callback + " what=" + msg.what);            }            msg.recycle();        }}...public static Looper myLooper() {    return sThreadLocal.get();}...

第2行：方法直接返回了sThreadLocal存储的Looper实例，如果me为null则抛出异常，也就是说looper方法必须在prepare方法之后运行。
第6行：拿到该looper实例中的mQueue（消息队列）
13到45行：就进入了我们所说的无限循环。
14行：取出一条消息，如果没有消息则阻塞。
27行：使用调用 msg.target.dispatchMessage(msg);把消息交给msg的target的dispatchMessage方法去处理。Msg的target是什么呢？其实就是handler对象，下面会进行分析。
44行：释放消息占据的资源。

Looper主要作用：
1、 与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。

Handler

public Handler() {        this(null, false);}public Handler(Callback callback, boolean async) {        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 = callback;        mAsynchronous = async;    }

14行：通过Looper.myLooper()获取了当前线程保存的Looper实例，然后在19行又获取了这个Looper实例中保存的MessageQueue（消息队列），这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了。

然后看我们最常用的sendMessage方法：

   public final boolean sendMessage(Message msg)    {        return sendMessageDelayed(msg, 0);    }

   public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {        Message msg = Message.obtain();        msg.what = what;        return sendMessageDelayed(msg, delayMillis);    }

 public final boolean sendMessageDelayed(Message msg, long delayMillis)    {        if (delayMillis < 0) {            delayMillis = 0;        }        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }

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

辗转反侧最后调用了sendMessageAtTime，在此方法内部有直接获取MessageQueue然后调用了enqueueMessage方法，我们再来看看此方法：

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {        msg.target = this;        if (mAsynchronous) {            msg.setAsynchronous(true);        }        return queue.enqueueMessage(msg, uptimeMillis);    }

enqueueMessage中首先为meg.target赋值为this，也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去。

当Looper获取到消息后，回调创建这个消息的handler中的dispathMessage方法，下面来看一下这个方法：

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

第10行，调用了handleMessage方法，下面我们去看这个方法：

  /**     * Subclasses must implement this to receive messages.     */    public void handleMessage(Message msg) {    }

可以看到这是一个空方法，消息最终回调是我们在创建handler时复写handleMessage方法。

总结：
1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。

2、Looper.loop()会让当前线程进入一个无限循环，不断从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。

3、Handler提供了多个构造方法，如果有手动传入的参数Looper，则与传入的Looper所在的线程相关联，如果默认没有传入Looper则会得到当前线程中保存的Looper实例，进而与当前线程相关联。

4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。

5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。

Message

message有这么几点需要注意：

1.尽管Message有public的默认构造方法，但是你应该通过Message.obtain()来从消息池中获得空消息对象，以节省资源。

2.如果你的message只需要携带简单的int信息，请优先使用Message.arg1和Message.arg2来传递信息，这比用Bundle更省内存

3.擅用message.what来标识信息，以便用不同方式处理message。

拓展

1、在主线程（UI线程）里，我们并没有显示的调用Looper.prepare()和Looper.loop()方法，创建Handler时也没有传入Looper对象，是因为在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。Looper对象直接使用主线程（UI线程）的Looper对象。

2、在其它线程里，如果创建Handler时不传入Looper对象，那么，这个Handler将不能接收处理消息。在这种情况下，通用的作法是：

 class LooperThread extends Thread {                   public Handler mHandler;                   public void run() {                            Looper.prepare();                            mHandler = new Handler() {                                   public void handleMessage(Message msg) {                                     // process incoming messages here                                    }                            };                        Looper.loop();                     }                }

3、ANR异常的理解：当用户执行操作(比如点击了一个按钮)系统会生成一个Message对象，把用户操作的信息写入Message对象，并把这个Message对象压入MessageQueue队列的尾部。系统过一段时间(一般是五秒)后会再来检查，刚刚放入的信息是不是已经被处理了，如果信息还在队列中就表明。处理前面信息的过程当中发生的阻塞，用户的操作没有及时得到响应。系统弹出ANR对话框。

4、UI线程需要保持一直运行的状态，所以要有一个循环保持这个线程不会死掉，但这个线程又必需阻塞，以减少cpu的消耗。android中的这个循环就是通过Looper实现的。有了这个 Looper，Looper就占据了整个线程，导致所有的方法想在些线程中运行就必需通过这个Looper，所以要有个方法可以进入这个Looper的内部。MessageQueue就担当了这个通道 的角色。Message担当了集合的角色。所有在UI线程中运行的方法都必需通过MessageQueue进入Looper内部，不管是用户定义的方法还是系统事件包括onCreate(),onStop(),用户点击事件等等。

5、不是所有的Handler都能更新UI
Handler处理消息总是在创建Handler的线程里运行。而我们的消息处理中，不乏更新UI的操作，不正确的线程直接更新UI将引发异常。因此，需要时刻关心Handler在哪个线程里创建的。如何更新UI才能不出异常呢？SDK告诉我们，有以下4种方式可以从其它线程访问UI线程(也即线程间通信)：

Activity.runOnUiThread(Runnable)
View.post(Runnable)
View.postDelayed(Runnable, long)
在UI线程中创建的Handler

其中，重点说一下的是View.post(Runnable)方法。在post(Runnableaction)方法里，View获得当前线程（即UI线程）的Handler，然后将action对象post到Handler里。在Handler里，它将传递过来的action对象包装成一个Message（Message的callback为action），然后将其投入UI线程的消息循环中。在 Handler再次处理该Message时，有一条分支（未解释的那条）就是为它所设，直接调用runnable的run方法。而此时，已经路由到UI线程里，因此，我们可以毫无顾虑的来更新UI。

几点小结 ：
一个Looper对应一个MessageQueue，一个线程对应一个Looper，一个Looper可以对应多个Handler
不确定当前线程时，更新UI时尽量调用View.post方法。
handler应该由处理消息的线程创建，Handler的处理过程运行在创建Handler的线程里 。handler与创建它的线程相关联，而且也只与创建它的线程相关联。handler运行在创建它的线程中，所以，如果在handler中进行耗时的操作，会阻塞创建它的线程。
Android的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper。主线程（UI线程）就是一个消息循环的线程。
Looper.myLooper(); //获得当前的Looper Looper.getMainLooper() //获得UI线程的Lopper
Handle的初始化函数（构造函数），如果没有参数，那么他就默认使用的是当前的Looper，如果有Looper参数，就是用对应的线程的Looper。 如果一个线程中调用Looper.prepare()，那么系统就会自动的为该线程建立一个消息队列，然后调用Looper.loop();之后就进入了消息循环，这个之后就可以发消息、取消息、和处理消息。

线程之间的消息如何进行传递示例

主线程给自己发送Message

package test.message; import android .app .Activity;import android.os.Bundle;import android.os.Handler;import android.os.Looper;import android.os.Message;import android.view.View ;import android.widget.Button;import android.widget.TextView ;public class MainActivity extends Activity {     private Button btnTest;    private TextView textView;    private Handler handler ;    @Override    public void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.main);        btnTest = (Button)this.findViewById(R.id.btn_01);        textView = (TextView)this.findViewById(R.id.view_01);        btnTest.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View arg0) {                Looper looper = Looper.getMainLooper(); //主线程的Looper对象                //这里以主线程的Looper对象创建了handler ，                //所以，这个handler 发送的Message会被传递给主线程的MessageQueue。                handler = new MyHandler(looper);                handler .removeMessages(0);                //构建Message对象                //第一个参数：是自己指定的message代号，方便在handler 选择性地接收                //第二三个参数没有什么意义                //第四个参数需要封装的对象                Message msg = handler .obtainMessage(1,1,1,"主线程发消息了");                handler .sendMessage(msg); //发送消息            }        });    }    class MyHandler extends Handler{        public MyHandler(Looper looper){            super(looper);        }        public void handleMessage(Message msg){            super.handleMessage(msg);            textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);        }    }}

其他线程给主线程发送Message

package test.message; import android.app.Activity; import android.os.Bundle;import android.os.Handler;import android.os.Looper;import android.os.Message;import android.view.View;import android.widget.Button;import android.widget.TextView;public class MainActivity extends Activity {     private Button btnTest;    private TextView textView;    private Handler handler ;    @Override    public void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.main);        btnTest = (Button)this.findViewById(R.id.btn_01);        textView = (TextView)this.findViewById(R.id.view_01);        btnTest.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View arg0) {                //可以看出这里启动了一个线程来操作消息的封装和发送的工作                //这样原来主线程的发送就变成了其他线程的发送，简单吧？呵呵                new MyThread().start();                }        });    }    class MyHandler extends Handler{        public MyHandler(Looper looper){            super(looper);        }        public void handleMessage(Message msg){            super.handleMessage(msg);            textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);        }    }    //加了一个线程类    class MyThread extends Thread{        public void run(){            Looper looper = Looper.getMainLooper(); //主线程的Looper对象            //这里以主线程的Looper对象创建了handler ，            //所以，这个handler 发送的Message会被传递给主线程的MessageQueue。            handler = new MyHandler(looper);            //构建Message对象            //第一个参数：是自己指定的message代号，方便在handler 选择性地接收            //第二三个参数没有什么意义            //第四个参数需要封装的对象            Message msg = handler .obtainMessage(1,1,1,"其他线程发消息了");            handler .sendMessage(msg); //发送消息                    }    }}

主线程给其他线程发送Message

package test.message; import android.app.Activity; import android.os.Bundle;import android.os.Handler;import android.os.Looper;import android.os.Message;import android.view.View;import android.widget.Button;import android.widget.TextView;public class MainActivity extends Activity {     private Button btnTest;    private TextView textView;    private Handler handler ;    @Override    public void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.main);        btnTest = (Button)this.findViewById(R.id.btn_01);        textView = (TextView)this.findViewById(R.id.view_01);        //启动线程        new MyThread().start();            btnTest.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View arg0) {                //这里handler 的实例化在线程中                //线程启动的时候就已经实例化了                Message msg = handler .obtainMessage(1,1,1,"主线程发送的消息");                handler .sendMessage(msg);            }        });    }    class MyHandler extends Handler{        public MyHandler(Looper looper){            super(looper);        }        public void handleMessage(Message msg){            super.handleMessage(msg);            textView.setText("我是主线程的Handler，收到了消息："+(String)msg.obj);        }    }    class MyThread extends Thread{        public void run(){            Looper.prepare(); //创建该线程的Looper对象，用于接收消息            //注意了：这里的handler 是定义在主线程中的哦，呵呵，            //前面看到直接使用了handler 对象，是不是在找，在什么地方实例化的呢？            //现在看到了吧？？？呵呵，开始的时候实例化不了，因为该线程的Looper对象            //还不存在呢。现在可以实例化了            //这里Looper.myLooper()获得的就是该线程的Looper对象了            handler = new ThreadHandler(Looper.myLooper());            //这个方法，有疑惑吗？            //其实就是一个循环，循环从MessageQueue中取消息。            //不经常去看看，你怎么知道你有新消息呢？？？            Looper.loop();         }        //定义线程类中的消息处理类        class ThreadHandler extends Handler{            public ThreadHandler(Looper looper){                super(looper);            }            public void handleMessage(Message msg){                //这里对该线程中的MessageQueue中的Message进行处理                //这里我们再返回给主线程一个消息                handler = new MyHandler(Looper.getMainLooper());                Message msg2 = handler .obtainMessage(1,1,1,"子线程收到:"+(String)msg.obj);                handler .sendMessage(msg2);            }        }    }}

其他线程给自己发送Message

package test.message; import android.app.Activity; import android.os.Bundle;import android.os.Handler;import android.os.Looper;import android.os.Message;import android.view.View;import android.widget.Button;import android.widget.TextView;public class MainActivity extends Activity {     private Button btnTest;    private TextView textView;    private Handler handler ;    @Override    public void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.main);        btnTest = (Button)this.findViewById(R.id.btn_01);        textView = (TextView)this.findViewById(R.id.view_01);        btnTest.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View arg0) {                //启动线程                new MyThread().start();                }        });    }    class MyHandler extends Handler{        public MyHandler(Looper looper){            super(looper);        }        public void handleMessage(Message msg){            super.handleMessage(msg);            textView.setText((String)msg.obj);        }    }        class MyThread extends Thread{        public void run(){            Looper.prepare(); //创建该线程的Looper对象            //这里Looper.myLooper()获得的就是该线程的Looper对象了            handler = new ThreadHandler(Looper.myLooper());            Message msg = handler .obtainMessage(1,1,1,"我自己");            handler .sendMessage(msg);            Looper.loop();         }        //定义线程类中的消息处理类        class ThreadHandler extends Handler{            public ThreadHandler(Looper looper){                super(looper);            }            public void handleMessage(Message msg){                //这里对该线程中的MessageQueue中的Message进行处理                //这里我们再返回给主线程一个消息                //加入判断看看是不是该线程自己发的信息                if(msg.what == 1 && msg.obj.equals("我自己")){                    handler = new MyHandler(Looper.getMainLooper());                    Message msg2 = handler .obtainMessage(1,1,1,"禀告主线程:我收到了自己发给自己的Message");                    handler .sendMessage(msg2);                                }            }        }    }}

用到的xml文件，main.xml ：

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    android rientation="vertical"    android:layout_width="fill_parent"    android:layout_height="fill_parent"    ><TextView  android:id="@+id/view_01"    android:layout_width="fill_parent"     android:layout_height="wrap_content"     android:text="@string/hello "    /><Button android:id="@+id/btn_01"     android:layout_width="fill_parent"     android:layout_height="wrap_content"     android:text="测试消息" /></LinearLayout>