Handler真的难？看完这篇文章你就懂了！-六虎

在Android开发中，Handler是一个非常重要的组件，它可以用来完成线程之间的通信和任务调度。本篇文章将介绍Handler的运用办法和原理，帮助读者更好地了解Android开发中的线程处理。

什么是Handler？

Handler是Android中的一个音讯处理器，它可以接纳并处理其他线程发来的音讯。简略来说，Handler便是一个用来处理音讯的东西类，它可以将音讯发送给其他线程，也可以接纳其他线程发送的音讯进行处理。

Handler的运用办法

运用Handler的根本流程为：创立Handler方针 -> 发送音讯 -> 处理音讯。

在运用 Handler 之前，需求了解一些相关概念：

线程：是独立运转的程序段，履行的代码是一个单独的任务。
音讯行列：是一种存储音讯的数据结构，支撑先进先出的行列操作。
Looper：可以让线程不停地从音讯行列中取出音讯并处理，是线程与音讯行列交互的桥梁。
Message：是 Android 中处理音讯的根本类，可以带着一些数据，用于在 Handler 中进行处理。

创立Handler方针

在运用Handler之前，需求先创立一个Handler方针。创立Handler方针的办法有两种：

在主线程中创立Handler方针：

在主线程中创立Handler方针非常简略，只需求在主线程中创立一个Handler方针即可：
```
Handler handler = new Handler();
```
在子线程中创立Handler方针：

在子线程中创立Handler方针需求先获取到主线程的Looper方针，然后运用Looper方针来创立Handler方针：
```
Handler handler = new Handler(Looper.getMainLooper());
```

发送音讯

创立Handler方针之后，就可以运用它来发送音讯了。发送音讯的办法有两种：

运用Handler的post()办法：

运用Handler的post()办法可以将一个Runnable方针发送到Handler地点的音讯行列中。Runnable方针中的代码会在Handler地点的线程中履行。
```
handler.post(new Runnable() {
    @Override
    public void run() {
        // 在Handler地点的线程中履行的代码
    }
});
```
运用Handler的sendMessage()办法：

运用Handler的sendMessage()办法可以将一个Message方针发送到Handler地点的音讯行列中。Message方针中可以带着一些数据，用于在Handler中进行处理。
```
Message message = new Message();
message.what = 1;
message.obj = "Hello World!";
handler.sendMessage(message);
```

除了根本用法，Handler还有一些高级用法，下面列举了几个常用的：

运用HandlerThread创立带有音讯行列的线程，避免频频地创立线程；
运用Message.obtain()来获取Message方针，避免频频地创立方针；
运用Handler的sendEmptyMessage()办法来发送空音讯。

处理音讯

当其他线程发送音讯到Handler地点的音讯行列中时，Handler就会接纳到这些音讯并进行处理。处理音讯的办法有两种：

重写Handler的handleMessage()办法：

重写Handler的handleMessage()办法可以处理其他线程发送的音讯。handleMessage()办法中的代码会在Handler地点的线程中履行。

Handler handler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case 1:
                String message = (String) msg.obj;
                // 处理音讯的代码
                break;
            default:
                break;
        }
    }
};

完成Handler.Callback接口：

完成Handler.Callback接口可以处理其他线程发送的音讯。Callback接口中的办法会在Handler地点的线程中履行。

Handler.Callback callback = new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        switch (msg.what) {
            case 1:
                String message = (String) msg.obj;
                // 处理音讯的代码
                break;
            default:
                break;
        }
        return true;
    }
};
Handler handler = new Handler(callback);

Handler的原理

在Handler的背后，实际上是运用了音讯行列和线程通信的机制。当其他线程发送音讯时，音讯会被参加到Handler地点的音讯行列中。然后，Handler会从音讯行列中取出音讯进行处理。

音讯行列和Looper

音讯行列和Looper是 Handler 完成的基础。每个线程都有一个音讯行列（Message Queue），音讯行列中存储着行列的所有音讯（Message）。线程经过一个 Looper 来办理它的音讯行列，经过不断地从音讯行列中读取音讯，完成了线程的音讯循环 (Message Loop) 的功用。

public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;
    for (;;) {
        Message msg = queue.next(); // might block
        // 一旦有音讯，就会回来Message方针
        msg.target.dispatchMessage(msg);
    }
}

如上所示，一个线程中的音讯无限循环直到行列里没有音讯为止（MessageQueue.next()）。音讯经过 Message.target 特点来找到它想要履行的 Handler，然后被分配到正确的线程中而且得到履行。一旦有音讯，就会调用 dispatchMessage(Message) 办法进行分发。

音讯分发

音讯分发是Handler 的核心部分，在它的内部逻辑中，也是最为关键的部分。

在 Handler 中，音讯分发的流程如下：

1.1. 发送音讯

由其他线程调用 Handler 的办法向音讯行列中发送音讯。

Handler handler = new Handler() ;
handler.post(new Runnable(){
    @Override
    public void run() {
        // 在其他线程发送音讯
    }
});

1.2. 创立 Message 方针

将需求传输的数据封装成 Message 类型的方针，然后将该方针塞入音讯行列中。

Message msg = new Message();
msg.obj = "音讯内容";
handler.sendMessage(msg);

1.3. 将音讯参加音讯行列

Handler 将音讯放入音讯行列中。

在 Handler 内部，新构建的音讯经过 enqueueMessage() 办法被参加到 MessageQueue 相应的内存块中，而且会在该内存块的标记 next 表明下一个内存块的索引号。

public void sendMessageAtTime(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;
    }
    msg.target = this;
    queue.enqueueMessage(msg, uptimeMillis);
}

而 enqueueMessage() 办法的核心逻辑，便是紧接着找到音讯行列中最近的一个时刻戳比当时时刻小的音讯，将新音讯插入到这个音讯之后。

boolean enqueueMessage(Message msg, long when) {
    synchronized (this) {
        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.");
        }
        boolean needWake;
        if (mBlocked) {
            // If the queue is blocked, then we don't need to wake
            // any waiters since there can be no waiters.
            msg.markInUse();
            needWake = false;
        } else {
            msg.markInUse();
            needWake = mMessagesForQueue.enqueueMessage(msg, when);
        }
        if (needWake) {
            nativeWake(mPtr);
        }
    }
    return true;
}

1.4. Looper 开启音讯循环

Looper 不断轮询内部 MessageQueue 中的音讯，获取音讯后在 Handler 中进行分发处理。

在 Looper 类中，强制让当时线程创立一个 Looper 方针，并经过调用 QualityLooper 结构函数 create 办法捕获该方针（一般用于构建线程的音讯循环）。接下来，经过调用 run 办法被延迟1秒钟来发动上下文中的音讯循环。

public static void prepare() {
    prepare(true);
}
public static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}
public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            continue;
        }
        msg.target.dispatchMessage(msg);
    }
}

这个办法是一个无限循环办法，在每个循环中，Looper 都会从自己的音讯行列中获取一个音讯，假如行列为空，则一向循环等待新的音讯到来，直到被调用 quit() 办法，才停止循环。在获取到音讯之后，调用 msg.target.dispatchMessage(msg) 进行音讯的分发处理。

1.5. 查找方针 Handler

Looper 不断轮询音讯行列，获取音讯后，注意到 MessageQueue.next() 办法中有这样一行代码：

msg.target.dispatchMessage(msg);

1.6. 传递 Message 方针

从音讯中获取到 target 特点，它便是当时这个Message方针所属的 Handler，并履行该Handler的 handleMessage(Message) 办法。

dispatchMessage(Message) 的核心代码是判断 Message.target 是否为 null，不为 null 则将音讯传递给方针 Handler，假如为 null，则直接抛出异常。

void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        // 音讯带有回调办法，假如 callback 不为空，那么就直接履行
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            // 尝试将音讯抛给 mCallback
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg); // 假如音讯中没有 callback，那就履行 handleMessage(msg)
    }
 }
// 处理具体的 Message
public void handleMessage(Message msg) {
    switch (msg.what) {
        // 根据音讯类型分发处理
        default:
            break;
    }
}

当 Handler 接纳到音讯时，它会回调自己的 handleMessage(Message) 办法处理音讯。

在 handleMessage(Message) 办法中，咱们可以编写各种不同的逻辑，并对当时情况下的音讯进行处理。这一般包含对音讯类型的检查以及音讯带着的数据的解析和操作。

当咱们在 handleMessage(Message) 办法中完成了所有处理后，咱们就可以将数据发送回发送音讯的线程，或将数据传递给其他线程进行进一步处理。

总结

本篇文章深入探讨了 Handler 的原理，首要包含了音讯行列和 Looper 的相关概念，以及音讯的发送和处理。除此之外，还讲了当不同线程的音讯需求在 Handler 中处理时，需求用到 Looper、MessageQueue 和 Handler 这三个关键组件的协同作业。

Handler真的难？看完这篇文章你就懂了！

什么是Handler？

Handler的运用办法

创立Handler方针

发送音讯

处理音讯

Handler的原理

音讯行列和Looper

音讯分发

总结

推荐

作者信息

Handler真的难？看完这篇文章你就懂了！

什么是Handler？

Handler的运用办法

创立Handler方针

发送音讯

处理音讯

Handler的原理

音讯行列和Looper

音讯分发

总结

推荐

相关文章

使用Alfred + Gitee搭建免费图床

大型 APP 的性能优化思路

JS进阶 | ES6新增的数据结构

你可能一直在kt文件中写Java代码

作者信息