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

最新推荐文章于 2020-06-19 22:25:28 发布
最新推荐文章于 2020-06-19 22:25:28 发布
阅读量335 收藏
点赞数
分类专栏： android开发技巧收集

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

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

代码下载

main.xml

[java] view plain copy print ?
  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>

LooperThreadActivity.java

[java] view plain copy print ?
  1. package com.example.thread;  
  2.   
  3. import com.example.test.R;  
  4.   
  5. import android.annotation.SuppressLint;  
  6. import android.app.Activity;  
  7. import android.os.Bundle;  
  8. import android.os.Handler;  
  9. import android.os.Looper;  
  10. import android.os.Message;  
  11. import android.util.Log;  
  12. import android.view.View;  
  13. import android.view.View.OnClickListener;  
  14.   
  15. public class LooperThreadActivity extends Activity{  
  16.   
  17.     private final int MSG_HELLO = 0;  
  18.     private Handler mHandler;  
  19.     @Override  
  20.     protected void onCreate(Bundle savedInstanceState) {  
  21.         super.onCreate(savedInstanceState);  
  22.         setContentView(R.layout.main13);  
  23.         new CustomThread().start();  
  24.         findViewById(R.id.send_btn).setOnClickListener(new OnClickListener() {  
  25.             @Override  
  26.             public void onClick(View v) {  
  27.                 String str = "hello";  
  28.                 Log.e("Test", "MainThread is ready to send msg:" + str);  
  29.                 mHandler.obtainMessage(MSG_HELLO, str).sendToTarget();  
  30.             }  
  31.         });  
  32.     }  
  33.       
  34.     class CustomThread extends Thread{  
  35.   
  36.         @SuppressLint("HandlerLeak")  
  37.         @Override  
  38.         public void run() {  
  39.             //建立消息循环的步骤   
  40.             Looper.prepare();//1.初始化Looper   
  41.             mHandler = new Handler(){//2、绑定handler到CustomThread实例的Looper对象     
  42.                 @Override  
  43.                 public void handleMessage(Message msg) {  
  44.                      switch(msg.what) {    
  45.                         case MSG_HELLO:    
  46.                             Log.e("Test", "CustomThread receive msg:" + (String) msg.obj);    
  47.                         }    
  48.                 }  
  49.             };  
  50.             Looper.loop();//4、启动消息循环     
  51.         }  
  52.           
  53.     }  
  54.       
  55. }  
package com.example.thread;

import com.example.test.R;

import android.annotation.SuppressLint;
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{

	private final int MSG_HELLO = 0;
	private Handler mHandler;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main13);
		new CustomThread().start();
		findViewById(R.id.send_btn).setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				String str = "hello";
				Log.e("Test", "MainThread is ready to send msg:" + str);
				mHandler.obtainMessage(MSG_HELLO, str).sendToTarget();
			}
		});
	}
	
	class CustomThread extends Thread{

		@SuppressLint("HandlerLeak")
		@Override
		public void run() {
			//建立消息循环的步骤
			Looper.prepare();//1.初始化Looper
			mHandler = new Handler(){//2、绑定handler到CustomThread实例的Looper对象  
				@Override
				public void handleMessage(Message msg) {
					 switch(msg.what) {  
	                    case MSG_HELLO:  
	                        Log.e("Test", "CustomThread receive msg:" + (String) msg.obj);  
	                    }  
				}
			};
			Looper.loop();//4、启动消息循环  
		}
		
	}
	
}

原理：

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

1、初始化Looper

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

3、定义处理消息的方法

4、启动消息循环

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

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

Looper.java

[java] view plain copy print ?
  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 copy print ?
  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 copy print ?
  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 copy print ?
  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 copy print ?
  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界面》中，UI线程在创建的时候就建立了消息循环(在ActivityThread的public static final void main(String[] args)方法中实现)，因此我们可以在其他线程给UI线程的handler发送消息，达到更新UI的目的。

转载博文地址：http://blog.csdn.net/mylzc/article/details/6771331 

mypanlong
关注
专栏目录
Android异步处理三：Handler+Looper+MessageQueue深入详解
lzc的专栏
09-13 5万+
本博文地址：http://blog.csdn.net/mylzc/article/details/6771331 转载请注明出处 Android异步处理系列文章索引 Android异步处理一：使用Thread+Handler实现非UI线程更新UI界面
Android之Handler、Message、MessageQueue、Looper详解
最新发布
是阿超
12-06 2727
Android之Handler、Message、MessageQueue、Looper详解
Android handler Looper MessageQueen Message 关系
毛毛虫
10-03 339
Message  : 用于向Handler传递消息的对象 MessageQueen : 存储Message对象的队列 Lopper : 死循环去监听MessageQueen消息队列,如果有Handler需要的数据,取出来交给Handler处理(相当于一个秘书去接收Handler(老板)所需要的信息,如果这个信息在MessageQueen中存在,则取出来交个Handler处理) Handler
Handler+Looper+MessageQueue
09-10
Handler+Looper+MessageQueue
Handler+Looper+MessageQueue+Message机制
01-03
作用： 跨线程通信，异步通信。当子线程中进行耗时操作后需要更新UI时，通过Handler将有关的UI操作切换到主线程中执行。 四要素： Message（消息）：需要被传递的消息，其中包含了消息标识(what)，消息处理数据和处理对象(arg1，arg2，obj)，发送该消息的Handler对象(target)等，由MessageQueue统一列队，最终由Handler处理。 MessageQueue（消息队列）：由Looper负责管理，管理Handler发送过来的Message，其底层实现采用的是单链表。 Handler（处理者）：负责Message的发送及处理。通过 Handler.send
Android应用开发——线程间通信之Handler+Looper+MessageQueue
好记性不如烂键盘
04-12 985
1、需求       每个Android应用程序都运行在一个dalvik虚拟机进程中，进程开始的时候会启动一个主线程(MainThread)，主线程负责处理和ui相关的事件，因此主线程通常又叫UI线程。而由于Android采用UI单线程模型，所以只能在主线程中对UI元素进行操作。如果在非UI线程直接对UI进行了操作，则会报错
Android 异步处理 Handler+Looper+MessageQueue深入详解
09-26
Handler、Looper和MessageQueue是Android异步处理机制中的核心组件，它们共同构建了一个消息传递系统，使得在不同线程间进行数据交换变得可能。下面我们将深入探讨这三个组件的工作原理及其在实际开发中的应用。 ...
AsyncTask陷阱之:Handler,Looper与MessageQueue的详解
09-05
在Android开发中，`Handler`、`Looper`和`MessageQueue`是处理线程间通信的关键组件，特别是当涉及到UI更新时。这篇文章将深入解析这三个概念，以及它们在`AsyncTask`中的应用和潜在陷阱。 首先，`Handler`是...
Android Handler机制-Looper、Handler、MessageQueue、Message的关系
鸿蒙开发知识记录
06-19 667
一、概述 Handler是Android中处理异步消息的机制。Looper、Handler、MessageQueue、Message概括来说就是：Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息Message，然后回调相应的消息处理函数，而消息的创建者就是一个或多个Handler，执行完成一个消息后则继续循环。 二、MessageQueue详解 消息队列MessageQueue就是存放消息的队列。那队列中存储的消息是什么呢？.
Android开发知识（六）消息处理机制Handler+Looper+MessageQueue的原理分析（下）
热门推荐
lc_miao的专栏
08-23 1万+
在上一篇博文中，我们已经学习过了消息处理机制的基础，对这个过程所涉及到的几个重要的类也有了一定的了解，如果在这方面不清楚也没看过上一篇博文的读者，请点击先阅读《 Android开发知识（五）消息处理机制的基础（Handler+Looper+MessageQueue+Message）》 在这篇博文中，我们来分析这个通信的过程。长话短说，我们直接从handler的sendMessage()一步步说起
android的消息处理机制（图+源码分析）——Looper,Handler,Message
06-06
android源码中包含了大量的设计模式， 除此以外， android sdk还精心为我们设计了各种helper类， 对于和我一样渴望水平得到进阶的人来说， 都太值得一读了。 这不， 前几天为了了解android的消息处理机制， 我看 了Looper， Handler， Message这几个类的源码， 结果又一次被googler的设计震撼了， 特与大家分享。 android的消息处理有三个核心类： Looper,Handler和Message。 其实还有一个Message Queue（消息队列） ， 但是MQ被封装到Looper里面了， 我们不会直接与 MQ打交道， 因此我没将其作为核心类。
android后台服务开启,各界面展示示例
12-11
解决了ListView异步下载条目混乱,在service中开启异步,在任一界面,拿到异步进度信息,并加载显示示例.采用双层回调方式,具体逻辑在各个数据完成,异步下载,实现完全分离广播,通过回调在数据适配器中获取界面数据.
全面总结Android中线程的异步处理方式
09-02
主要介绍了Android中线程的异步处理方式,讲解了Looper、Handler和Handler post三种方式,其中Handler自然是重点,需要的朋友可以参考下
Android异步消息处理机制，详细理解Handler,Looper,Messagequeue三者的关系
Kevin
03-27 440
1.Looper主要有prepare()和loop()两个方法。 先看prepare()方法，该方法不能被调用两次，即保证了一个线程只能有一个looper实例 Looper构造方法中，创建了一个messageQueue。 loop()方法拿到消息队列，然后不断轮循消息队列，调用msg.target.dispatch()方法去处理，其实msg.target就是handler
Handler+Looper+MessageQueue深入详解案例
03-15 1000
Android通过Looper、Handler来实现消息循环机制，Android消息循环是针对线程的（每个线程都可以有自己的消息队列和消息循环）。  Android系统中，Looper负责管理线程的消息队列和消息循环。我们可以通过Loop.myLooper()得到当前线程的Looper对象，通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象。  一个线程可以
Looper、MessageQueue、Handler三者关系理解
charles674611395的专栏
07-15 1532
1.Looper有两个关键的放perpare(),loop()方法，在prepare方法会创建一个Looper对象，然后保存在ThreadLocal中，该方法只能被调用一次，否则会抛出异常，这样保证了一个线程只有一个looper，Looper构造器中创建MessageQueue对象 public static final void prepare() {           if
hanlder机制 总结篇
weixin_38503885的博客
08-02 194
一.背景   总结了很多大神对handler机制（感谢各位大神），很早以前就写了，最近回想居然想不起来，于是在硬盘的某个阴暗角落把他找出来了，方便以后查阅，写成博客，方便自己，也方便大家 二.概述         Android使用消息机制实现线程间的通信，线程通过Looper建立自己的消息循环，MessageQueue是FIFO的消息队列，Looper负责从MessageQueue中取出消...
Attempt to read from field 'android.os.MessageQueue android.os.Looper.mQueue' on a null object refer
Kodulf的专栏
10-08 8202
//如果主线程使用了子线程的looper，那么就会报错 mHandler = new Handler(myThread.looper); Attempt to read from field 'android.os.MessageQueue android.os.Looper.mQueue' on a null object refer 2019-10-08 17:36:39.892 1269...
深入理解Android消息机制：Handler、Looper与MessageQueue
当Handler将消息放入MessageQueue后，Looper会按照顺序依次取出并处理这些消息。 4. 线程：在Android中，主线程是处理用户界面交互的线程，它拥有一个预配置的Looper。非主线程若需要进行UI操作，需要通过Handler与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值