`

Handler+Looper+MessageQueue深入详解

 
阅读更多



 Handler+Looper+MessageQueue深入详解



 

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

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

LooperThreadActivity.java

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{
   
 
 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

<?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>

 

原理:

 

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

1、 初始化Looper

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

3、 定义处理消息的方法

4、 启动消息循环

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

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

Looper.java

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

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

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

 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

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的线程。

  • 大小: 59.4 KB
分享到:
评论

相关推荐

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

    Handler、Looper和MessageQueue是Android异步处理机制中的核心组件,它们共同构建了一个消息传递系统,使得在不同线程间进行数据交换变得可能。下面我们将深入探讨这三个组件的工作原理及其在实际开发中的应用。 ...

    Message,MessageQueue,Looper,Handler详解

    ### Message,MessageQueue,Looper,Handler详解 #### 一、几个关键概念 ##### 1、MessageQueue:消息队列 MessageQueue是一种数据结构,顾名思义,它充当了一个消息队列的角色,用来存放各种消息对象。每一个线程...

    Android 之 Looper、MessageQueue、Handler 与消息循环

    ### Android之Looper、MessageQueue、Handler与消息循环详解 #### 一、概述 在Android开发过程中,消息处理机制是至关重要的部分,它涉及到应用程序如何管理、传递和响应各种事件。本篇文章将深入探讨Android中...

    Message,MessageQueue,Looper,Handler详解[归类].pdf

    MessageQueue与Looper紧密配合,当MessageQueue中有新消息时,Looper会取出并分发给对应的Handler进行处理。主线程默认已经创建了MessageQueue和Looper,而在其他非主线程中,开发者需要手动调用`Looper.prepare()`...

    AsyncTask陷阱之:Handler,Looper与MessageQueue的详解

    在Android开发中,`Handler`、`Looper`和`MessageQueue`是处理线程间通信的关键组件,特别是当涉及到UI更新时。这篇文章将深入解析这三个概念,以及它们在`AsyncTask`中的应用和潜在陷阱。 首先,`Handler`是...

    android线程 Handler Message Queue AsyncTask线程模型 线程交互 + 修改Button样式 示例 最终easy整合版

    本文将深入探讨Android中的线程模型,重点讲解Handler、Message Queue和AsyncTask,并提供修改Button样式的示例以及如何将这些概念整合到一个易用的方案中。 1. **Android线程模型** Android系统的主线程,也称为...

    Android的消息处理机制--Message,MessageQueue

    4. **Looper**:充当MessageQueue和Handler之间的桥梁角色,负责循环取出MessageQueue中的消息,并交给对应的Handler处理。 #### 四、消息处理流程 1. **创建Handler**:每个需要处理消息的线程都需要一个Handler...

    详解Android中Handler的内部实现原理

    Handler是Android系统中用于线程间通信的关键组件,它的内部实现原理涉及到...在编程实践中,深入理解Handler、Looper和MessageQueue之间的关系,以及它们如何协同工作,对于编写高效且稳定的Android应用至关重要。

    Handler_Message_Looper小结

    `Looper` 的典型工作模式是调用 `loop()` 方法进入无限循环,从而不断从 `MessageQueue` 中读取消息并传递给对应的 `Handler` 进行处理。 4. **MessageQueue (消息队列)**:`MessageQueue` 是一个 `Looper` 的成员...

    Android消息机制Handler的工作过程详解

    Handler、Looper和MessageQueue之间的关系关系 在理解Handler的工作原理前,需要了解三个关键组件:Handler、Looper和MessageQueue。它们共同构成了Android的消息传递机制。 1. **MessageQueue**:消息队列,用于...

    Android的Message机制(Handler、Message、Looper)

    #### 三、MessageQueue详解 `MessageQueue`是存放消息的地方,它的主要作用是维护一个消息列表,并且提供了向列表中添加消息(`enqueueMessage`)和从列表中移除消息(`next`)的方法。 #### 四、Handler详解 `...

    Android消息处理机制Looper和Handler详解

    Message:消息,其中包含了消息ID,消息处理对象以及处理的数据等,由MessageQueue统一列队,终由Handler处理。 Handler:处理者,负责Message的发送及处理。使用Handler时,需要实现handleMessage(Message msg)方法...

    android多线程handler/message机制详解

    Looper 负责从其内部的 MessageQueue 中拿出一个个的 Message 给 Handler 进行处理。 Message 是什么?Message 是后台进程返回的数据,里面可以存储 Bundle 等数据格式。MessageQueue 是线程对应 Looper 的一部分,...

    深入Android Handler,MessageQueue与Looper关系

    关联篇:Handler内存泄漏详解及其解决方案 一说到Android的消息机制,自然就会联想到Handler,我们知道Handler是Android消息机制的上层接口,因此我们在开发过程中也只需要和Handler交互即可,很多人认为Handler的...

    Android handler message奇怪用法详解

    7. **MessageQueue插队**:`MessageQueue.next()`方法允许开发者获取并立即处理下一个消息,跳过其他等待的消息,但这需要谨慎使用,因为它可能破坏消息的正常顺序。 8. **Message的target属性**:除了Handler外,...

    Handler机制详解

    Handler与Looper、MessageQueue的关系可以用CPU执行指令的模型来比喻:Looper相当于CPU,不断从内存(MessageQueue)中读取指令(Message),然后由CPU的执行单元(Handler)执行这些指令。 **AsyncTask**是Android提供的...

    Android7.0 MessageQueue详解

    在Android 7.0中,MessageQueue主要用于组织和管理待处理的消息,这些消息通常由Handler对象发送,并在适当的时机由Looper处理。理解MessageQueue的工作原理对于优化应用程序性能和解决多线程同步问题至关重要。 1....

    Android¦-Message Queue

    - **MessageQueue的创建**:Looper会创建一个MessageQueue,用于存储各个对象发送的消息,包括用户界面事件和系统事件。 - **定义Handler子类**:开发者可以定义Handler的子类来接收Looper分发的消息。Handler子类...

Global site tag (gtag.js) - Google Analytics