Handler使用及源码解析

Handler机制是什么？

当我们运行一个Android应用程序时，系统会创建一个进程，这个进程就是我们的主线程（UI线程-ActivityThread）。为了防止阻塞UI主线程，我们一般会将耗时的操作放到子线程中进行处理，处理完之后更新UI，但是Android不允许在子线程中操作UI，这违背了Android单线程模型的原则（Android UI操作并不是线程安全的并且这些操作必须在主线程中执行），为此Android提供了一套异步消息传递机制——Handler消息机制来实现线程之间的数据传递。因此，Handler机制是Android给我们提供的用于更新UI的一套消息处理机制。Handler贯穿了整个Android系统，它随处可见，在Android开发中有着非常重要的地位。

Handler机制主要角色

Android系统是以消息驱动的，整个消息流程可以大致概括为：

发送消息 --> 添加消息到队列 --> 从队列中获取消息 --> 处理消息

上面的流程可以引出几个重要的类，分别是发送消息的Handler，将消息Message发送到消息队列MessageQueue，Looper从消息队列循环取出消息，然后交给Handler处理。

• Handler：处理者，负责Message的发送及处理。发送消息一般是使用Handler的sendMessage()方法、postXXX()方法；发出的消息最终会传递到Handler的handleMessage(Message msg)方法进行处理。
• Message：被发送和处理的消息，它可以在内部携带少量的信息，用于在不同线程之间传递数据。Message的what、arg1和arg2字段可以携带一些整型数据，obj字段携带一个Object对象。
• MessageQueue：存放消息的消息队列，用来存放Handler发送过来的消息，并按照FIFO（先进先出）规则执行。存放的Message并非实际意义的保存，而是将Message以链表的方式串联起来的，等待Looper的抽取。 每个线程中只会有一个MessageQueue对象。
• Looper：循环的从MessageQueue中取消息给 Handler处理，调用Looper的loop()方法后，就会进入一个无限循环当中，然后每当发现MessageQueue中存在一条满足执行条件的消息时，就会将它取出，并调用Handler的dispatchMessage(msg)方法进行分发处理。每个线程中只会有一个Looper对象。

了解Handler、Message、MessageQueue以及Looper的基本概念后，再来理一下Handler消息发送和处理的基本流程。首先创建一个Handler对象，并重写handleMessage()方法。然后当有需要传递数据的需求时，就创建一个Message对象，并通过创建的Handler将这条消息发送出去。之后这条消息会被添加到MessageQueue的队列中等待被处理，而Looper则会一直尝试从MessageQueue中取出待处理消息，最后分发回Handler的handleMessage()方法中。如果Handler是在主线程中创建或者创建Handler的时候构造函数中传入了Looper.getMainLooper()，则此时handleMessage()方法中的代码将会在主线程中运行，于是就可以进行UI操作了。整个异步消息处理机制的流程大致如下：

Handler机制的基本使用及源码解析

上面介绍了Handler机制中的几个重要角色，现在就通过实例来一步步的了解Handler源码。

首先在activity_main.xml中新增一个TextView和一个Button：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="10dp"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/infoText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

    <Button
        android:id="@+id/updateBtn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:text="update" />
</LinearLayout>

然后在MainActivity中完成以下逻辑：

class MainActivity : AppCompatActivity() {
   

    private lateinit var binding: ActivityMainBinding
    private val handler = object : Handler(Looper.getMainLooper()) {
   
        override fun handleMessage(msg: Message) {
   
            super.handleMessage(msg)
            binding.infoText.text = "handle message"
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
   
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        binding.updateBtn.setOnClickListener {
   
            thread {
   
                handler.sendEmptyMessage(0)
            }
        }
    }
}

可以看到我们创建了一个handler对象，并重写了handleMessage方法；然后在点击updateBtn的时候创建一个子线程，在子线程中使用handler的sendEmptyMessage方法发送消息。

示例中控件的绑定使用的是ViewBinding

运行一下项目，点击一下updateBtn按钮就可以在子线程中发送消息，并在主线程中更新UI了。

发送消息

发送消息有2种方式：sendXXX和postXXX。

1. sendXXX()系列方法主要有下面几个方法

sendEmptyMessage(int what);//发送一个空的消息
sendMessage(@NonNull Message msg);//发送消息，消息中可以携带参数
sendMessageDelayed(int what, long delayMillis);//延时delayMillis(ms)发送消息
sendMessageAtTime(int what, long uptimeMillis);//未来某一时间点发送消息

2. postXXX()系列方法主要有下面几个方法

post(@NonNull Runnable r);//提交计划任务马上执行
postDelayed(@NonNull Runnable r, long delayMillis);//提交计划任务延时Nms执行
postAtTime(@NonNull Runnable r, long uptimeMillis);//提交计划任务在未来的时间点执行

handler.sendXXX()和handler.postXXX()最终都会调用Handler的sendMessageDelayed()方法。

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

然后调用了Handler的sendMessageAtTime方法

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);
}

再调用Handler的enqueueMessage(queue, msg, uptimeMillis)方法

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
   
	msg.target = this;
	msg.workSourceUid = ThreadLocalWorkSource.getUid();

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

可以看到最终调用了MessageQueue的私有方法enqueueMessage(msg, uptimeMillis) 方法，点进MessageQueue看看。

boolean enqueueMessage(Message msg, long when) {
   
    if (msg.target == null) {
   
      	//判断msg.target是否为空，target就是Handler
        throw new IllegalArgumentException("Message must have a target.");
    }

    synchronized (this) {
   
        if (msg.isInUse()) {
   
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        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)的时间(when)在所有消息队列的消息最前面，则把				msg插入到队头,最先执行
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
   
            // Inserted within the middle of the queue.  Usually we don't have to wake
            // up the event queue unless there is a barrier at the head of the queue
            // and the message is the earliest asynchronous message in the queue.
          	//将消息按时间顺序插入到Messag