Handler+Looper+MessageQueue深入详解案例

最新推荐文章于 2025-08-14 10:16:47 发布

转载最新推荐文章于 2025-08-14 10:16:47 发布 · 1k 阅读

文章标签：

#android #import #null #thread #layout #string

android开发专栏收录该内容

41 篇文章

订阅专栏

本文详细解析了Android中Looper、Handler、MessageQueue的工作原理及如何实现消息循环机制。通过一个具体的例子介绍了如何在一个自定义线程中接收和处理主线程发送的消息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Android通过Looper、Handler来实现消息循环机制，Android消息循环是针对线程的（每个线程都可以有自己的消息队列和消息循环）。

Android系统中，Looper负责管理线程的消息队列和消息循环。我们可以通过Loop.myLooper()得到当前线程的Looper对象，通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象。

一个线程可以存在（当然也可以不存在）一个消息队列和一个消息循环（Looper）。

Activity是一个UI线程，运行于主线程中，Android系统在启动的时候会为Activity创建一个消息队列和消息循环（Looper）。

Handler的作用是把消息加入特定的（Looper）消息队列中，并分发和处理该消息队列中的消息。构造Handler的时候可以指定一个Looper对象，如果不指定则利用当前线程的Looper创建。

Activity、Looper、Handler，Thread的关系如下图所示：

一个Activity中可以创建多个工作线程或者其他的组件，如果这些线程或者组件把他们的消息放入Activity的主线程消息队列，那么该消息就会在主线程中处理了。

因为主线程一般负责界面的更新操作，并且Android系统中的widget不是线程安全的，所以这种方式可以很好的实现Android界面更新。在Android系统中这种方式有着广泛的运用。

那么一个线程怎样把消息放入主线程的消息队列呢？答案是通过Handle对象，只要Handler对象以主线程的Looper创建，那么调用Handler的sendMessage等接口，将会把消息放入队列都将是放入主线程的消息队列。并且将会在Handler主线程中调用该handler的handleMessage接口来处理消息。

更多Android消息队列的信息请参看： http://my.unix-center.net/~Simon_fu/?p=652

下面这个图从另外一个角度描述了他们的关系：

转载自：http://www.oschina.net/question/4873_19701

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

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

LooperThreadActivity.java

 
   01package  com.zhuozhuo; 
 
   02  
 
   03import  android.app.Activity; 
 
   04import  android.os.Bundle; 
 
   05import  android.os.Handler; 
 
   06import  android.os.Looper; 
 
   07import  android.os.Message; 
 
   08import  android.util.Log; 
 
   09import  android.view.View; 
 
   10import  android.view.View.OnClickListener; 
 
   11  
 
   12public  class LooperThreadActivity extendsActivity{ 
 
   13    /** Called when the activity is first created. */
 
   14      
 
   15    privatefinal int MSG_HELLO =  0; 
 
   16    privateHandler mHandler; 
 
   17      
 
   18    @Override
 
   19    publicvoid onCreate(Bundle savedInstanceState) {
 
   20        super.onCreate(savedInstanceState);
 
   21        setContentView(R.layout.main);
 
   22        newCustomThread().start();//新建并启动CustomThread实例
 
   23          
 
   24        findViewById(R.id.send_btn).setOnClickListener(newOnClickListener() { 
 
   25              
 
   26            @Override
 
   27            publicvoid 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    classCustomThread extendsThread { 
 
   42        @Override
 
   43        publicvoid run() { 
 
   44            //建立消息循环的步骤
 
   45            Looper.prepare();//1、初始化Looper
 
   46            mHandler =new Handler(){//2、绑定handler到CustomThread实例的Looper对象
 
   47                publicvoid handleMessage (Message msg) {//3、定义处理消息的方法
 
   48                    switch(msg.what) {
 
   49                    caseMSG_HELLO: 
 
   50                        Log.d("Test","CustomThread receive msg:" + (String) msg.obj); 
 
   51                    }
 
   52                }
 
   53            };
 
   54            Looper.loop();//4、启动消息循环
 
   55        }
 
   56    }  
 
   57}

main.xml

 
   01<?xmlversion="1.0"encoding="utf-8"?>
 
   02<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
 
   03    android:orientation="vertical"
 
   04    android:layout_width="fill_parent"
 
   05    android:layout_height="fill_parent"
 
   06    >  
 
   07<TextView  
 
   08    android:layout_width="fill_parent" 
 
   09    android:layout_height="wrap_content" 
 
   10    android:text="@string/hello"
 
   11    />  
 
   12<Buttonandroid:text="发送消息"android:id="@+id/send_btn"android:layout_width="wrap_content"android:layout_height="wrap_content"></Button>
 
   13</LinearLayout>

Log打印结果：

原理：

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

1、初始化Looper

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

3、定义处理消息的方法

4、启动消息循环

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

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

Looper.java

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

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

Looper.java

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

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

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

Handler.java

 
   01final  MessageQueue mQueue; 
 
   02 finalLooper mLooper; 
 
   03public  Handler() { 
 
   04        if(FIND_POTENTIAL_LEAKS) { 
 
   05            finalClass<? extendsHandler> klass = getClass(); 
 
   06            if((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
 
   07                    (klass.getModifiers() & Modifier.STATIC) ==0) { 
 
   08                Log.w(TAG,"The following Handler class should be static or leaks might occur: "+ 
 
   09                    klass.getCanonicalName());
 
   10            }
 
   11        }
 
   12  
 
   13        mLooper = Looper.myLooper();
 
   14        if(mLooper == null) {
 
   15            thrownew RuntimeException( 
 
   16                "Can't create handler inside thread that has not called Looper.prepare()");
 
   17        }
 
   18        mQueue = mLooper.mQueue;
 
   19        mCallback =null; 
 
   20}

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

 
   01public  static final  void loop() { 
 
   02       Looper me = myLooper();
 
   03       MessageQueue queue = me.mQueue;
 
   04         
 
   05       // Make sure the identity of this thread is that of the local process,
 
   06       // and keep track of what that identity token actually is.
 
   07       Binder.clearCallingIdentity();
 
   08       finallong ident = Binder.clearCallingIdentity();
 
   09         
 
   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               finallong 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   }

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

 
   01public  void dispatchMessage(Message msg) { 
 
   02        if(msg.callback != null) {
 
   03            handleCallback(msg);
 
   04        }else { 
 
   05            if(mCallback != null) {
 
   06                if(mCallback.handleMessage(msg)) { 
 
   07                    return;
 
   08                }
 
   09            }
 
   10            handleMessage(msg);
 
   11        }
 
   12}

可见，当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.youkuaiyun.com/mylzc/article/details/6771331