Android异步处理三：Handler+Looper+MessageQueue深入详解 .

冷不防 2024-04-19 15:03 65阅读 0赞

本博文地址：[http://blog.csdn.net/mylzc/article/details/6771331][http_blog.csdn.net_mylzc_article_details_6771331] 转载请注明出处

[Android异步处理系列文章索引][Android]

[Android异步处理一：使用Thread+Handler实现非UI线程更新UI界面][Android_Thread_Handler_UI_UI]

[Android异步处理二：使用AsyncTask异步更新UI界面][Android_AsyncTask_UI]

[Android异步处理三：Handler+Looper+MessageQueue深入详解][http_blog.csdn.net_mylzc_article_details_6771331]

[Android异步处理四：AsyncTask的实现原理][Android_AsyncTask]

在《[Android异步处理一：使用Thread+Handler实现非UI线程更新UI界面》][Android_Thread_Handler_UI_UI]中，我们讲到使用Thread+Handler的方式来实现界面的更新，其实是在非UI线程发送消息到UI线程，通知UI线程进行界面更新，这一篇我们将深入学习Android线程间通讯的实现原理。

**概述**：Android使用消息机制实现线程间的通信，线程通过Looper建立自己的消息循环，MessageQueue是FIFO的消息队列，Looper负责从MessageQueue中取出消息，并且分发到消息指定目标Handler对象。Handler对象绑定到线程的局部变量Looper，封装了发送消息和处理消息的接口。

**例子**：在介绍原理之前，我们先介绍Android线程通讯的一个例子，这个例子实现点击按钮之后从主线程发送消息"hello"到另外一个名为” CustomThread”的线程。

[代码下载][Link 1]

LooperThreadActivity.java

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  package com.zhuozhuo;
2.  
3.  import android.app.Activity;
4.  import android.os.Bundle;
5.  import android.os.Handler;
6.  import android.os.Looper;
7.  import android.os.Message;
8.  import android.util.Log;
9.  import android.view.View;
10. import android.view.View.OnClickListener;
11. 
12. public class LooperThreadActivity extends Activity\{
13. /\*\* Called when the activity is first created. \*/
14. 
15. private final int MSG\_HELLO = 0;
16. private Handler mHandler;
17. 
18. @Override
19. public void onCreate(Bundle savedInstanceState) \{
20. super.onCreate(savedInstanceState);
21. setContentView(R.layout.main);
22. new CustomThread().start();//新建并启动CustomThread实例 
23. 
24. findViewById(R.id.send\_btn).setOnClickListener(new OnClickListener() \{
25. 
26. @Override
27. public void onClick(View v) \{ //点击界面时发送消息 
28. String str = "hello";
29. Log.d("Test", "MainThread is ready to send msg:" \+ str);
30. mHandler.obtainMessage(MSG\_HELLO, str).sendToTarget();//发送消息到CustomThread实例 
31. 
32. \}
33. \});
34. 
35. \}
36. 
37. 
38. 
39. 
40. 
41. class CustomThread extends Thread \{
42. @Override
43. public void run() \{
44. //建立消息循环的步骤 
45. Looper.prepare();//1、初始化Looper 
46. mHandler = new Handler()\{ //2、绑定handler到CustomThread实例的Looper对象 
47. public void handleMessage (Message msg) \{ //3、定义处理消息的方法 
48. switch(msg.what) \{
49. case MSG\_HELLO:
50. Log.d("Test", "CustomThread receive msg:" \+ (String) msg.obj);
51. \}
52. \}
53. \};
54. Looper.loop();//4、启动消息循环 
55. \}
56. \}
57. \}

package com.zhuozhuo;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Looper;
    import android.os.Message;
    import android.util.Log;
    import android.view.View;
    import android.view.View.OnClickListener;
    
    public class LooperThreadActivity extends Activity{
        /** Called when the activity is first created. */
    	
    	private final int MSG_HELLO = 0;
        private Handler mHandler;
    	
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
            new CustomThread().start();//新建并启动CustomThread实例
            
            findViewById(R.id.send_btn).setOnClickListener(new OnClickListener() {
    			
    			@Override
    			public void onClick(View v) {//点击界面时发送消息
    				String str = "hello";
    		        Log.d("Test", "MainThread is ready to send msg:" + str);
    				mHandler.obtainMessage(MSG_HELLO, str).sendToTarget();//发送消息到CustomThread实例
    				
    			}
    		});
            
        }
        
        
        
        
        
        class CustomThread extends Thread {
        	@Override
        	public void run() {
        		//建立消息循环的步骤
        		Looper.prepare();//1、初始化Looper
        		mHandler = new Handler(){//2、绑定handler到CustomThread实例的Looper对象
        			public void handleMessage (Message msg) {//3、定义处理消息的方法
        				switch(msg.what) {
        				case MSG_HELLO:
        					Log.d("Test", "CustomThread receive msg:" + (String) msg.obj);
        				}
        			}
        		};
        		Looper.loop();//4、启动消息循环
        	}
        }
    }

main.xml

**\[html\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  <?xml version="1.0" encoding="utf-8"?>
2.  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3.  android:orientation="vertical"
4.  android:layout\_width="fill\_parent"
5.  android:layout\_height="fill\_parent"
6.  >
7.  <TextView
8.  android:layout\_width="fill\_parent"
9.  android:layout\_height="wrap\_content"
10. android:text="@string/hello"
11. />
12. <Button android:text="发送消息" android:id="@+id/send\_btn" android:layout\_width="wrap\_content" android:layout\_height="wrap\_content"></Button>
13. </LinearLayout>

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

Log打印结果：

![0_1315898732HoOZ.gif][]

**原理：**

**我们看到，为一个线程建立消息循环有四个步骤：**

**1、 初始化Looper**

**2、 绑定handler到CustomThread实例的Looper对象**

**3、 定义处理消息的方法**

**4、 启动消息循环**

下面我们以这个例子为线索，深入Android源代码，说明Android Framework是如何建立消息循环，并对消息进行分发的。

**1、 初始化Looper : Looper.prepare()**

Looper.java

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  private static final ThreadLocal sThreadLocal = new ThreadLocal();
2.  public static final void prepare() \{
3.  if (sThreadLocal.get() != null) \{
4.  throw new RuntimeException("Only one Looper may be created per thread");
5.  \}
6.  sThreadLocal.set(new Looper());
7.  \}

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

一个线程在调用Looper的静态方法prepare()时，这个线程会新建一个Looper对象，并放入到线程的局部变量中，而这个变量是不和其他线程共享的（关于ThreadLocal的介绍）。下面我们看看Looper()这个构造函数：

Looper.java

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  final MessageQueue mQueue;
2.  private Looper() \{
3.  mQueue = new MessageQueue();
4.  mRun = true;
5.  mThread = Thread.currentThread();
6.  \}

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

可以看到在Looper的构造函数中，创建了一个消息队列对象mQueue，此时，调用Looper. prepare()的线程就建立起一个消息循环的对象（此时还没开始进行消息循环）。

**2、 绑定handler到CustomThread实例的Looper对象 : mHandler= new Handler()**

Handler.java

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  final MessageQueue mQueue;
2.  final Looper mLooper;
3.  public Handler() \{
4.  if (FIND\_POTENTIAL\_LEAKS) \{
5.  final Class<? extends Handler> klass = getClass();
6.  if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
7.  (klass.getModifiers() & Modifier.STATIC) == 0) \{
8.  Log.w(TAG, "The following Handler class should be static or leaks might occur: " \+
9.  klass.getCanonicalName());
10. \}
11. \}
12. 
13. mLooper = Looper.myLooper();
14. if (mLooper == null) \{
15. throw new RuntimeException(
16. "Can't create handler inside thread that has not called Looper.prepare()");
17. \}
18. mQueue = mLooper.mQueue;
19. mCallback = null;
20. \}

final MessageQueue mQueue;
     final Looper mLooper;
    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;
    }

Handler通过mLooper = Looper.myLooper();绑定到线程的局部变量Looper上去，同时Handler通过mQueue =mLooper.mQueue;获得线程的消息队列。此时，Handler就绑定到创建此Handler对象的线程的消息队列上了。

**3、定义处理消息的方法：Override public void handleMessage (Message msg)\{\}**

子类需要覆盖这个方法，实现接受到消息后的处理方法。

**4、启动消息循环 ： Looper.loop()**

所有准备工作都准备好了，是时候启动消息循环了！Looper的静态方法loop()实现了消息循环。

Looper.java

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  public static final void loop() \{
2.  Looper me = myLooper();
3.  MessageQueue queue = me.mQueue;
4.  
5.  // Make sure the identity of this thread is that of the local process, 
6.  // and keep track of what that identity token actually is. 
7.  Binder.clearCallingIdentity();
8.  final long ident = Binder.clearCallingIdentity();
9.  
10. while (true) \{
11. Message msg = queue.next(); // might block 
12. //if (!me.mRun) \{ 
13. // break; 
14. //\} 
15. if (msg != null) \{
16. if (msg.target == null) \{
17. // No target is a magic identifier for the quit message. 
18. return;
19. \}
20. if (me.mLogging!= null) me.mLogging.println(
21. ">>>>> Dispatching to " \+ msg.target + " "
22. \+ msg.callback + ": " \+ msg.what
23. );
24. msg.target.dispatchMessage(msg);
25. if (me.mLogging!= null) me.mLogging.println(
26. "<<<<< Finished to " \+ msg.target + " "
27. \+ msg.callback);
28. 
29. // Make sure that during the course of dispatching the 
30. // identity of the thread wasn't corrupted. 
31. final long newIdent = Binder.clearCallingIdentity();
32. if (ident != newIdent) \{
33. Log.wtf("Looper", "Thread identity changed from 0x"
34. \+ Long.toHexString(ident) + " to 0x"
35. \+ Long.toHexString(newIdent) + " while dispatching to "
36. \+ msg.target.getClass().getName() + " "
37. \+ msg.callback + " what=" \+ msg.what);
38. \}
39. 
40. msg.recycle();
41. \}
42. \}
43. \}

public static final void loop() {
            Looper me = myLooper();
            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();
            
            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);
                    
                    // 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("Looper", "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();
                }
            }
        }

while(true)体现了消息循环中的“循环“，Looper会在循环体中调用queue.next()获取消息队列中需要处理的下一条消息。当msg != null且msg.target != null时，调用msg.target.dispatchMessage(msg);分发消息，当分发完成后，调用msg.recycle();回收消息。

msg.target是一个handler对象，表示需要处理这个消息的handler对象。Handler的void dispatchMessage(Message msg)方法如下：

Handler.java

**\[java\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  public void dispatchMessage(Message msg) \{
2.  if (msg.callback != null) \{
3.  handleCallback(msg);
4.  \} else \{
5.  if (mCallback != null) \{
6.  if (mCallback.handleMessage(msg)) \{
7.  return;
8.  \}
9.  \}
10. handleMessage(msg);
11. \}
12. \}

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

可见，当msg.callback== null 并且mCallback == null时，这个例子是由handleMessage(msg);处理消息，上面我们说到子类覆盖这个方法可以实现消息的具体处理过程。

**总结**：从上面的分析过程可知，消息循环的核心是Looper，Looper持有消息队列MessageQueue对象，一个线程可以把Looper设为该线程的局部变量，这就相当于这个线程建立了一个对应的消息队列。Handler的作用就是封装发送消息和处理消息的过程，让其他线程只需要操作Handler就可以发消息给创建Handler的线程。由此可以知道，在上一篇《[Android异步处理一：使用Thread+Handler实现非UI线程更新UI界面》][Android_Thread_Handler_UI_UI]中，UI线程在创建的时候就建立了消息循环(在ActivityThread的public static final void main(String\[\] args)方法中实现)，因此我们可以在其他线程给UI线程的handler发送消息，达到更新UI的目的。

本博文地址：[http://blog.csdn.net/mylzc/article/details/6771331][http_blog.csdn.net_mylzc_article_details_6771331] 转载请注明出处

[http_blog.csdn.net_mylzc_article_details_6771331]: http://blog.csdn.net/mylzc/article/details/6771331
[Android]: http://blog.csdn.net/mylzc/article/details/6777767
[Android_Thread_Handler_UI_UI]: http://blog.csdn.net/mylzc/article/details/6736988
[Android_AsyncTask_UI]: http://blog.csdn.net/mylzc/article/details/6772129
[Android_AsyncTask]: http://blog.csdn.net/mylzc/article/details/6774131
[Link 1]: http://www.androidtwitters.com/blog/looperthread.rar
[view plain]: http://blog.csdn.net/mylzc/article/details/6771331#
[0_1315898732HoOZ.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/93f5b00f6c34484897b5a6b784ac67b5.gif