Android Handler机制

Posted ITRenj

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android Handler机制相关的知识,希望对你有一定的参考价值。

作为一个android程序员,我想大家都知道在做一些比较耗时的操作的时候都不会放在主线程,比如网络请求、数据库操作等(尤其是网络请求,在Android4.0之后强制不能放在主线程中执行,否则抛出android.os.NetworkOnMainThreadException异常),而更新UI的操作的都是由UI线程处理。那么有这样一个需求,我在一个新的线程中获取到数据,然后设置到界面上,这就涉及到了两个线程,用于更新界面的UI线程不知道什么时候数据获取完成可以更新界面了,那怎么办呢?Google就给我们提供了一个解决方案,也就是我们今天主要说明的内容——Android中的Handler消息机制

首先来一个简单使用:

private static final int HANDLER_TEST_WHAT = 0x01; // 定义测试what

// 创建Handler对象,并重写handleMessage()方法处理消息
private Handler handler = new Handler()
	@Override
	public void handleMessage(Message msg) 
	    int what = msg.what; // 获取消息的what
	    // 通过what对消息进行判断,不同消息不同的处理
	    if(what == HANDLER_TEST_WHAT)
		// 处理消息
	    
	
;

// 创建一个子线程发送消息
new Thread()
    @Override
    public void run() 
	Message message = Message.obtain(); // 创建一个消息对象,使用obtain()重用回收的消息对象
	message.what = HANDLER_TEST_WHAT;   // 设置Message的 what
	handler.sendMessage(message);       // 发送一个消息
    
.start();

上面就是一个简单的例子,在子线程发送一个消息,然后在主线程就可以对消息进行处理,当然包括更新UI或者其他操作。

下面我们就从源码的角度查看与分析一下Handler消息机制,他是怎样将一个子线程的数据传递到主线程中的。

介绍Handler机制之前,首先了解几个概念:

  • **Message:**消息,理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI,则可发送一条包含更新信息的Message给UI线程。
  • **MessageQueue:**消息队列,用来存放通过Handler发布的消息并按时间进行排序,按照先进先出执行。
  • **Handler:**Handler是Message的主要处理者,负责将Message添加到消息队列以及对消息队列中的Message进行处理。
  • **Looper:**轮询器,扮演MessageQueue和Handler之间桥梁的角色,循环取出MessageQueue里面的Message,并交付给相应的Handler进行处理。

消息机制分析

从上面的示例中,我们先创建了一个Handler对象并且重写了 handleMessage() 方法用来处理接收到的消息,而消息的发送是通过 Handler 的sendMessage() 方法。也可以说,Handler机制是由 sendMessage() 方法开始,到 handleMessage() 方法结束,现在我们就来一步一步看看数据是怎样传递的,线程又是怎样切换的。

首先看看创建 Handler

最终调用的是 带两个参数 的构造方法,如下:

	public Handler(@Nullable Callback callback, boolean async) 
        
        mLooper = Looper.myLooper();
        if (mLooper == null) 
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        
        mQueue = mLooper.mQueue;
    

说明:

  1. Looper.myLooper():获取当前线程的 Looper 对象,也就是线程需要是一个 Looper 线程,主线程就是一个 Looper 线程,主线程为什么是一个Looper线程以及怎样将一个线程变为 Looper 线程,在《Android Handler分析 (三) Looper详解和Handler其他知识》中有说到。

     public static @Nullable Looper myLooper() 
         return sThreadLocal.get();
     
    
  2. mLooper.mQueue:就是一个 MessageQueue 对象,他是在 Looper 构造方法中初始化的

     private Looper(boolean quitAllowed) 
         mQueue = new MessageQueue(quitAllowed);
         mThread = Thread.currentThread();
     
    

我们创建了 Handler 对象之后,然后通过 Handler 的 sendMessage() 方法发送一个 Message,接下来看看 sendMessage() 方法做了写什么事

Handler#sendMessage() 方法

	public final boolean sendMessage(@NonNull Message msg) 
        return sendMessageDelayed(msg, 0);
    

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

	public boolean sendMessageAtTime(@NonNull 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);
    

	private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) 
		// 注意这行代码,将 Message 的 target 变量赋值成 this,也就是当前 Handler 对象
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) 
            msg.setAsynchronous(true);
        
        return queue.enqueueMessage(msg, uptimeMillis);
    

说明:

  1. sendMessage() 方法调用了一些 Message 类自身的发送方法,主要是处理消息发送时间(立马发送还是延迟发送等)
  2. 最终调用 enqueueMessage() 方法,在这个方法中又调用了 queue.enqueueMessage(msg, uptimeMillis) ,queue 就是 MessageQueue,所以查看一下 MessageQueue 中的 enqueueMessage() 方法
  3. 重点注意enqueueMessage() 方法中的 msg.target = this 代码,将 Message 的 target 变量赋值成 this,也就是当前 Handler对象

MessageQueue#enqueueMessage() 方法

boolean enqueueMessage(Message msg, long when) 
    if (msg.target == null) 
        throw new IllegalArgumentException("Message must have a target.");
    
    if (msg.isInUse()) 
        throw new IllegalStateException(msg + " This message is already in use.");
    

    synchronized (this) 
        if (mQuitting) 
            IllegalStateException e = new IllegalStateException(
                    msg.target + " sending message to a Handler on a dead thread");
            Log.w(TAG, e.getMessage(), e);
            msg.recycle();
            return false;
        

        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when < p.when) 
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
         else 
            Message prev;
            for (;;) 
                prev = p;
                p = p.next;
                if (p == null || when < p.when) 
                    break;
                
                if (needWake && p.isAsynchronous()) 
                    needWake = false;
                
            
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) 
            nativeWake(mPtr);
        
    
    return true;

这个方法所做的事情就是将 Message 对象根据发送时间添加到队列中,方法的具体分析在 《Android Handler分析 (二) MessageQueue详解》中。

Message 消息对象添加到 MessageQueue 中之后,在哪里取出来,并且传递到 handleMessage() 方法呢?

这里我们就有必要先说一下 Looper 线程了,一个类变为Looper线程并且能处理消息,主要有两步:

  1. 调用 Looper.prepare() 方法
  2. 调用 Looper.loop() 方法开始轮询

至于这两个方法具内容是什么我们这里就不说了,在《Android Handler分析 (三) Looper详解和Handler其他知识》中有分析,只需要知道 loop() 方法最重要的作用就是不断的循环调用 MessageQueue 的 next() 方法去获取 Message ,然后进行处理,而 MessageQueue 的 next() 方法的消息分析在 《Android Handler分析 (二) MessageQueue详解》中,它的主要作用就是按照顺序从队列里面取出 Message。

所以我们直接看 MessageQueue.next() 取到消息之后 Looper.loop() 方法是怎样处理的,核心代码如下:

public static void loop() 
	final Looper me = myLooper();
	final MessageQueue queue = me.mQueue;
	Message msg = queue.next();
	try 
        msg.target.dispatchMessage(msg);
     catch (Exception exception) 
     finally 
    

说明:

通过获取的 Message 对象的变量 target, 调用它的 dispatchMessage() 方法,并且将 msg 对象传递给 dispatchMessage() 方法。在上面,我们已经知道了 target 变量表示的就是 Handler,所以这里调用的就是 Handler 的 dispatchMessage() 方法了。

Handler#dispatchMessage() 方法

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

dispatchMessage() 方法中调用了 handleMessage(msg) 方法并传递 Message,这个方法我们在创建 Handler 时重写了。所以就走到了我们自己处理消息的部分。因为我们的这个Handler是在主线程创建的并且绑定的也是主线程的Looper,所以这个方法就在主线程当中执行了。

以上是关于Android Handler机制的主要内容,如果未能解决你的问题,请参考以下文章

Android Handler消息传递机制

Android Handler消息传递机制

Android 必懂系列 —— handler机制由浅及深到源码分析

Android消息机制之Handler

带你深入理解Android Handler机制

android中的Handler消息机制