Handler、MessageQueue、Looper，它们都是运行在UI线程上的吗？

Question

我正在尝试围绕线程进行思考，并且我知道我可以使用 Handler 将消息/可运行对象发布到 MessageQueue，而该消息又会被Looper 并发送回 Handler 进行处理。

如果我在活动中发布到 Handler ，则为 Activity、Handler、MessageQueue 和 Looper 全部运行在 UI 线程上？如果没有，有人可以解释一下这一切是如何结合在一起的吗？ :)

Answer 1

简短回答：它们都在同一个线程上运行。如果从 Activity 生命周期回调实例化，它们都在主 UI 线程上运行。

长答案：

线程可能有一个Looper，其中包含一个MessageQueue。为了使用此功能，您必须通过调用（静态）Looper.prepare() 在当前线程上创建一个Looper，然后通过调用（也是静态）<代码>Looper.loop()。它们是静态的，因为每个线程只应该有一个 Looper。

对loop()的调用通常在一段时间内不会返回，但会不断地从其中获取消息（“任务”、“命令”或任何您喜欢的名称） MessageQueue 并单独处理它们（例如，通过回调消息中包含的 Runnable）。当队列中没有消息时，线程会阻塞，直到有新消息为止。要停止Looper，您必须对其调用quit()（这可能不会立即停止循环，而是设置一个私有标志，定期从循环中检查该标志）循环，指示它停止）。

但是，您不能直接将消息添加到队列中。相反，您可以注册一个 MessageQueue.IdleHandler 来等待 queueIdle() 回调，您可以在其中决定是否要执行某些操作。所有处理程序都会依次调用。 （因此“队列”并不是真正的队列，而是定期调用的回调集合。）

关于上一段的注意事项： 这其实是我猜到的。我找不到任何相关文档，但这是有道理的。

更新：参见ahcox'评论和他的答案。

由于这是一项繁重的工作，框架提供了 Handler 类来简化事情。当您创建 Handler 实例时，它（默认情况下）绑定到已附加到当前线程的 Looper。 （Handler 知道要附加到什么 Looper，因为我们之前调用了 prepare()，它可能存储了对 Looper< 的引用。 /code> 在 ThreadLocal 中。）

使用 Handler，您只需调用 post() 即可“put一条消息进入线程的消息队列”（可以这么说）。 Handler 将处理所有 IdleHandler 回调内容，并确保您发布的 Runnable 被执行。 （如果您延迟发布，它还可能检查时间是否正确。）

需要明确的是：真正使循环线程做某事的唯一方法是发布消息到它的循环。这一直有效，直到您在循环器上调用 quit() 为止。

---

关于 android UI 线程： 在某个时刻（可能在创建任何活动等之前），框架已经设置了一个Looper（包含一个MessageQueue）并启动它。从此时起，UI 线程上发生的所有事情都将通过该循环进行。这包括活动生命周期管理等。您重写的所有回调（onCreate()、onDestroy()...）至少都是从该循环间接调度的。例如，您可以在异常的堆栈跟踪中看到这一点。 （你可以尝试一下，只需在 onCreate() 中的某处写入 int a = 1 / 0;...）

---

我希望这是有道理的。抱歉之前不清楚。

Answer 2

跟进问题的“这一切是如何结合在一起的”部分。正如 user634618 所写，循环器接管一个线程，在情况下是主 UI 线程
应用程序的主要Looper。

• Looper.loop() 将消息从消息队列中拉出。每个消息都有一个对其要返回给（目标成员）的关联处理程序的引用。
• 对于从队列中获取的每条消息，在 Looper.loop() 内：
  • loop() 使用存储在 Message 中作为其目标成员的 Handler 调用 public void Handler.dispatchMessage(Message msg)。
  • 如果消息有 Runnable 回调成员，则运行。
  • 否则，如果处理程序设置了共享回调，则运行。
  • 否则，将使用 Message 作为参数调用 Handler 的 handleMessage()。 （请注意，如果您像 AsyncTask 那样子类化 Handler，则可以像它一样重写 handleMessage()。）

关于所有协作对象位于同一 UI 线程上的问题，
必须在与其发送的 Looper 相同的线程上创建 Handler
消息至.
它的构造函数将查找当前的 Looper 并将其存储为成员，绑定
该Looper的Handler。
它还将直接在其自己的成员中引用该Looper的消息队列。
Handler 可用于从任何线程向 Looper 发送工作，但是这个
消息队列的标识路由要在 Looper 线程上完成的工作。

当我们在另一个线程上运行一些代码并希望发送一个 Runnable 在 UI 线程上执行时，我们可以这样做：

// h is a Handler that we constructed on the UI thread.
public void run_on_ui_thread(final Handler h, final Runnable r)
{
   // Associate a Message with our Handler and set the Message's
   // callback member to our Runnable:
   final Message message = Message.obtain(h, r);

   // The target is the Handler, so this asks our Handler to put
   // the Message in its message queue, which is the exact same
   // message queue associated with the Looper on the thread on
   // which the Handler was created:
   message.sendToTarget();
}

Answer 3

我尝试自己实现这些接口以理解这个概念。
为了简单起见，只需根据需要使用接口即可。
这是我的测试代码：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class TestLooper {

    public static void main(String[] args) {
        UIThread thread = new UIThread();
        thread.start();

        Handler mHandler = new Handler(thread.looper);
        new WorkThread(mHandler, "out thread").run();
    }
}

class Looper {
    private BlockingQueue<Message> message_list = new LinkedBlockingQueue<Message>();

    public void loop() {

        try {
            while (!Thread.interrupted()) {
                Message m = message_list.take();
                m.exeute();
            }
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public void insertMessage(Message msg) {
        message_list.add(msg);
    }

}

class Message {
    String data;
    Handler handler;

    public Message(Handler handler) {
        this.handler = handler;
    }

    public void setData(String data) {
        this.data = data;
    }

    public void exeute() {
        handler.handleMessage(this);
    }
}

class Handler {

    Looper looper;

    public Handler(Looper looper) {
        this.looper = looper;
    }

    public void dispatchMessage(Message msg) {
        System.out.println("Handler dispatchMessage" + Thread.currentThread());
        looper.insertMessage(msg);
    }

    public Message obtainMessage() {
        return new Message(this);
    }

    public void handleMessage(Message m) {
        System.out.println("handleMessage:" + m.data + Thread.currentThread());
    }
}

class WorkThread extends Thread {
    Handler handler;
    String tag;

    public WorkThread(Handler handler, String tag) {
        this.handler = handler;
        this.tag = tag;
    }

    public void run() {
        System.out.println("WorkThread run" + Thread.currentThread());
        Message m = handler.obtainMessage();
        m.setData("message " + tag);
        handler.dispatchMessage(m);
    }
}

class UIThread extends Thread {

    public Looper looper = new Looper();

    public void run() {

            //create handler in ui thread
        Handler mHandler = new Handler(looper);

        new WorkThread(mHandler, "inter thread").run();
        System.out.println("thead run" + Thread.currentThread());
        looper.loop();
    }

}

Answer 4

如果我向 Activity 中的处理程序发送消息，那么 Activity、Handler、MessageQueue 和 Looper 是否都在 UI 线程上运行？如果没有，有人可以解释一下这一切是如何结合在一起的吗？ :)

这取决于您如何创建 Handler

案例 1：

Handler()

默认构造函数将此处理程序与当前的 Looper 关联起来线程。

如果你在UI线程中像这样创建Handler，那么Handler就会与UI线程的Looper相关联。 MessageQueue 还与UI Thread 中的Looper 相关联。

案例2：

Handler (Looper looper)

使用提供的 Looper 而不是默认的 Looper。

如果我创建一个 HandlerThread 并将 HandlerThread 的 Looper 传递给 Handler， Handler 和 Looper 与 HandlerThread 相关，而不是与 UI Thread 相关。 Handler、MessageQueue 和 Looper 与 HandlerThread 相关联。

使用案例：您想要执行网络或 IO 操作。您无法在 UI 线程上执行它，因此 HandlerThread 对您来说很方便。

 HandlerThread handlerThread = new HandlerThread("NetworkOperation");
 handlerThread.start();
 Handler requestHandler = new Handler(handlerThread.getLooper());

如果您想将数据从 HandlerThread 传递回 UI 线程，您可以使用 UI 线程中的 Looper 创建另一个 Handler（例如 responseHandler ）并调用 sendMessage。 UI 线程 responseHandler 应覆盖 handleMessage

有关更多详细信息，请参阅这些帖子。

Looper 的用途是什么以及如何使用它？（概念）

Android：Toast一个线程（例如链接所有这些概念的代码）