对于Handler是怎么进行线程通信，它的原理又是什么，你了解多少？

题目：Handler怎么进行线程通信，原理是什么？

首先我们要知道这道题想考察什么？

1. 是否熟悉Handler的基本用法
2. 是否熟悉Handler消息机制的运行流程
3. 是否明白Handler进行线程通信的原理

考察的知识点

1. 利用Handler进行线程切换的基本流程
2. Handler消息机制涉及到的类以及之间的关系
3. Handler是怎样做到线程通信的

考生应该如何回答

1. 先说一下Handler机制的运行流程，以及涉及到的类之间的关系

   Handler消息机制主要涉及到四个类：Handler、Looper、MessageQueue、Message.

   Handler: 字面意为处理器，负责消息的分发与处理，内部持有一个looper对象和一个MessageQueue对象（MessageQueue对象通过looper对象获得）

   Looper: 字面意为循环器，跑在特定的线程里面，持有一个MessageQueue对象，主要通过loop()方法循环地从MessageQueue中来拿到当前线程需要处理的消息并处理。我们通常意义上的切换线程，归根结底就是切换到了这个方法中。为什么需要loop()循环？通常我们开启一个新的线程，当代码执行完线程也就结束了，如果想要该线程做到不断接收并处理外部发来的消息，就需要开启looper。

   MessageQueue: 消息队列，也就是存放Message的地方，维护了一个通过时间优先级排列的单链表，Handler发出的消息会先存进此队列再被取出执行。

   Message: 消息，可携带参数及标识，并持有发送该消息的Handler对象。post(Runnable)方式最后也会被改为Message对象，并将Runnable赋值给Message的callback，处理消息时调用。

   一次完整的事件发送与处理流程为：Handler调用sendMessage/post方法，调用其持有的MessageQueue对象的enqueueMessage方法将消息添加到消息队列，looper通过loop()方法会不断的从该MessageQueue中取出Message，并调用Message持有的target(Handler)对象的dispatchMessage方法，进而执行到Handler的handlerMessage或者Runnable的run方法或者额外的callback进行处理。

2. 说一下Handler怎么做到线程通信，其原理是什么

   我们在新建一个Handler的时候，在其构造方法中会给其持有的mLooper对象赋值，Handler通过mLooper实现与线程的绑定。

   mLooper对象可以在构造方法中传入，或者在构造方法中通过Looper.myLooper()方法获取。

   //Handler.java
   public Handler(@Nullable Callback callback, boolean async) {
       mLooper = Looper.myLooper();
       mQueue = mLooper.mQueue;
       mCallback = callback;
       mAsynchronous = async;
   }
   public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
       mLooper = looper;
       mQueue = looper.mQueue;
       mCallback = callback;
       mAsynchronous = async;
   }
   
   //Looper.java
   static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
   public static @Nullable Looper myLooper() {
       return sThreadLocal.get();
   }
   private static void prepare(boolean quitAllowed) {
       if (sThreadLocal.get() != null) { //当前线程中已经有looper对象，抛出异常
           throw new RuntimeException("Only one Looper may be created per thread");
       }
       sThreadLocal.set(new Looper(quitAllowed));
   }
   

   可以看到looper对象是以ThreadLocal的形式存放的，也就是每个线程中都有自己单独的looper对象。

   线程中的looper对象在调用Looper.prepare()方法的时候进行初始化并赋值，并且通过判空的方式来保证一个线程中只有一个looper对象。

   需要说明的一下是，主线程中的looper是在应用程序进程创建的时候，在ActivityThread的main()方法中进行创建并开启循环的，不需要我们手动创建，而子线程中的looper是需要我们自己调用prepare()/loop()方法来初始化并开启循环。

   //ActivityThread.java
   public static final void main(String[] args) {
       //主线程, 进程启动时自动调用
       Looper.prepareMainLooper()
       //由这里的loop()方法处理的消息运行在主线程
       Looper.loop();
   }
   
   //XXActivity.java
   new Thread() {
       @Override
       public void run() {
           super.run();
           //子线程, 需手动调用
           Looper.prepare();
           //由这里的loop()方法处理的消息运行在子线程
           Looper.loop();
       }
   }.start();
   

   由此我们知道了Looper.loop()在哪个线程调用，其消息循环就执行在哪个线程中。

   而Looper.loop()中干了什么事？就是获取到当前线程的looper对象（怎么获取的？前面说了，ThreadLocal中获取），再拿到其内部MessageQueue对象，从其中不断地取出消息并执行，也就是我们线程代码实际运行的地方。既然loop()中执行的是MessageQueue中的消息，我们不难想到，若想让代码执行在这个某个线程中，肯定是要跟这个线程的MessageQueue发生关系的。

   //Handler.java
   public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
       MessageQueue queue = mQueue; //这里的mQueue即mLooper对象中的MessageQueue
       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) {
       msg.target = this;
       msg.workSourceUid = ThreadLocalWorkSource.getUid();
       if (mAsynchronous) {
           msg.setAsynchronous(true);
       }
       return queue.enqueueMessage(msg, uptimeMillis); //将Message对象添加到MessageQueue队列中
   }
   
   //Looper.java (此处仅贴出关键代码)
   public static void loop() {
       final Looper me = myLooper();
       final MessageQueue queue = me.mQueue;
       for (;;) {
           Message msg = queue.next();
           msg.target.dispatchMessage(msg);
           //dispatchMessage 会调用到handler的handleMessage方法或者Runnable的run方法
           //或者额外传入的Callback的handleMessage方法.
       }
   }
   

   可以看到，当（比如子线程中）调用Handler.sendMessage时，会将消息传入该Handler所绑定的mLooper的MessageQueue中，这一步是发送消息的过程。也就是说，消息会从一个线程被发送到另一个线程的消息队列。如果创建Handler时传入的是主线程的looper对象，那么主线程中的Looper.loop()函数就会从这个MessageQueue中取到子线程发来的这个消息并执行。怎么执行呢？就是调用message.target.dispatchMessage() -> handleMessage()方法，而这里的target就是发送该消息的handler。而由于Looper.loop()是在主线程，所以这条消息也就执行在了主线程中。

   所以Handler完成线程通信通俗点说原理就是：在A线程中获得绑定了B线程looper的handler的引用，用此handler发送的消息会进入B线程的消息队列，最终会跑在B线程的Looper.loop()方法中，这样就完成了从A线程到B线程的通信。

   这里要区分一下线程对象和线程的概念：线程对象就是Thread对象，是虚拟机中实实在在存在的，文章中所说的哪个线程的mLooper对象，MessageQueue对象都是指这个Thread对象所持有的对象；而线程是系统调度的单位，是一段代码的运行过程，通过Thread类的start()方法来真实启动的。所以一个线程中调用Looper.loop()方法，从本线程对象的MessageQueue中拿数据，而这个MessageQueue，其他线程也可以通过Handler往里面发送消息（这里需要加锁来保证线程安全），这样就完成了线程的通信。线程通信本质上是线程间对象或者说内存的共享。

   下面以一段代码来更清楚地演示一下从子线程向主线程发送消息以及从主线程向子线程发送消息的过程。

   public class MyActivity extends AppCompatActivity {
   
       //与主线程绑定的Handler, 此处主动传入looper对象, 与调用默认构造方法效果是一样的
       Handler mMainHandler = new MainThreadHandler(Looper.myLooper());
       //与子线程绑定的Handler, 需要在子线程中创建, 定义为全局变量以便在主线程中引用
       SubThreadHandler mSubHandler;
   
       @Override
       protected void onCreate(@Nullable Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
   
           new Thread() {
               @Override
               public void run() {
                   super.run();
                   mMainHandler.sendEmptyMessage(0);      //子线程发送消息给主线程
                   Looper.prepare();                      //子线程中需要手动初始化looper
                   mSubHandler = new SubThreadHandler();  //初始化子线程Handler
                   Looper.loop();                         //开启循环
               }
           }.start();
   
           //主线程发送消息给子线程, 这里延后1秒钟以保证mSubHandler完成初始化
           mMainHandler.postDelayed(() -> mSubHandler.sendEmptyMessage(1), 1000);
   
       }
   
       private static class MainThreadHandler extends Handler {
   
           public MainThreadHandler(Looper looper) {
               super(looper);
           }
   
           @Override
           public void handleMessage(@NonNull Message msg) {
               super.handleMessage(msg);
               //do work in main thread
               Log.d("HandlerTest", "MainThreadHandler: " + msg.what + ", current thread: " + Thread.currentThread().getName());
           }
       }
   
       private static class SubThreadHandler extends Handler {
   
           @Override
           public void handleMessage(@NonNull Message msg) {
               super.handleMessage(msg);
               //do work in sub thread
               Log.d("HandlerTest", "SubThreadHandler: " + msg.what + ", current thread: " + Thread.currentThread().getName());
           }
       }
   }
   

   执行结果：

   10928-10928/com.xx.newtest D/HandlerTest: MainThreadHandler: 0, current thread: main
   10928-11722/com.xx.newtest D/HandlerTest: SubThreadHandler: 1, current thread: Thread-4

   首先得到的是子线程发送来的消息，执行在主线程；接着得到主线程发送来的消息，执行在子线程。