Handler、Thread和HandlerThread的差别

浅浅的花香味﹌ 2022-07-12 06:50 226阅读 0赞

# 概念梳理 #

### Handler ###

Handler是Android消息机制的上层接口，一个Handler允许你发送和处理消息（Message）以及与一个线程的消息队列相关的Runnable对象。

sdk官方解释：

/**
 * A Handler allows you to send and process {@link Message} and Runnable
 * objects associated with a thread's {@link MessageQueue}. Each Handler
 * instance is associated with a single thread and that thread's message
 * queue. When you create a new Handler, it is bound to the thread /
 * message queue of the thread that is creating it -- from that point on,
 * it will deliver messages and runnables to that message queue and execute
 * them as they come out of the message queue.
 * 
 * There are two main uses for a Handler: (1) to schedule messages and
 * runnables to be executed as some point in the future; and (2) to enqueue
 * an action to be performed on a different thread than your own.
 * 
 * Scheduling messages is accomplished with the
 * {@link #post}, {@link #postAtTime(Runnable, long)},
 * {@link #postDelayed}, {@link #sendEmptyMessage},
 * {@link #sendMessage}, {@link #sendMessageAtTime}, and
 * {@link #sendMessageDelayed} methods. The post versions allow
 * you to enqueue Runnable objects to be called by the message queue when
 * they are received; the sendMessage versions allow you to enqueue
 * a {@link Message} object containing a bundle of data that will be
 * processed by the Handler's {@link #handleMessage} method (requiring that
 * you implement a subclass of Handler).
 * 
 * When posting or sending to a Handler, you can either
 * allow the item to be processed as soon as the message queue is ready
 * to do so, or specify a delay before it gets processed or absolute time for
 * it to be processed. The latter two allow you to implement timeouts,
 * ticks, and other timing-based behavior.
 * 
 * When a
 * process is created for your application, its main thread is dedicated to
 * running a message queue that takes care of managing the top-level
 * application objects (activities, broadcast receivers, etc) and any windows
 * they create. You can create your own threads, and communicate back with
 * the main application thread through a Handler. This is done by calling
 * the same post or sendMessage methods as before, but from
 * your new thread. The given Runnable or Message will then be scheduled
 * in the Handler's message queue and processed when appropriate.
 */

讲人话版本：

一个Handler允许你发送和处理消息（Message）以及与一个线程的消息队列相关的Runnable对象。每个Handler实例都和单个线程以及该线程的消息队列有关。当你创建了一个新Handler，它就会和创建它的线程/消息队列绑定，在那以后，它就会传递消息以及runnable对象给消息队列，然后执行它们。
    
          需要使用Handler有两大主要的原因：
    
          （1）在将来的某个时间点调度处理消息和runnable对象；
    
          （2）将需要执行的操作放到其他线程之中，而不是自己的；
    
         调度处理消息是通过调用post(Runnable), postAtTime(Runnable, long),postDelayed(Runnable, long), sendEmptyMessage(int), sendMessage(Message),sendMessageAtTime(Message, long)和sendMessageDelayed(Message,long)等方法完成的。其中的post版本的方法可以让你将Runnable对象放进消息队列；sendMessage版本的方法可以让你将一个包含有bundle对象的消息对象放进消息队列，然后交由handleMessage(Message)方法处理。（这个需要你复写Handler的handleMessage方法）

但是由于Handler会关联一个单独的线程和消息队列。Handler默认关联主线程，虽然要提供Runnable参数，但默认是直接调用Runnable中的run()方法。也就是默认下会在主线程执行，如果在这里面的操作会有阻塞，界面也会卡住。所以  
Handler与子线程可以通过Message对象来传递数据, 这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象，(里面包含数据) , 把这些消息放入主线程队列中，配合主线程进行更新UI。

我们知道Handler是用来异步更新UI的，更详细的说是用来做线程间的通信的，更新UI时是子线程与UI主线程之间的通信。那么现在我们要是想子线程与子线程之间的通信要怎么做呢？当然说到底也是用Handler+Thread来完成（不推荐，需要自己操作Looper），Google官方很贴心的帮我们封装好了一个类，那就是刚才说到的：HandlerThread。（类似的封装对于多线程的场景还有AsyncTask）。

下面来看下HandlerThread的源码：

**
 * Handy class for starting a new thread that has a looper. The looper can then be 
 * used to create handler classes. Note that start() must still be called.
 */
 public class HandlerThread extends Thread {
 
 int mPriority;
 int mTid = -1;
 Looper mLooper;
 
 public HandlerThread(String name) {
 super(name);
 mPriority = Process.THREAD_PRIORITY_DEFAULT;
 }
 
 /**
 * Constructs a HandlerThread.
 * @param name
 * @param priority The priority to run the thread at. The value supplied must be from 
 * {@link android.os.Process} and not from java.lang.Thread.
 */
 public HandlerThread(String name, int priority) {
 super(name);
 mPriority = priority;
 }
 
 /**
 * Call back method that can be explicitly overridden if needed to execute some
 * setup before Looper loops.
 */
 protected void onLooperPrepared() {
 }
 
 @Override
 public void run() {
 mTid = Process.myTid();
 Looper.prepare();
 synchronized (this) {
 mLooper = Looper.myLooper();
 notifyAll();
 }
 Process.setThreadPriority(mPriority);
 onLooperPrepared();
 Looper.loop();
 mTid = -1;
 }
 
 /**
 * This method returns the Looper associated with this thread. If this thread not been started
 * or for any reason is isAlive() returns false, this method will return null. If this thread 
 * has been started, this method will block until the looper has been initialized. 
 * @return The looper.
 */
 public Looper getLooper() {
 if (!isAlive()) {
 return null;
 }
 
 // If the thread has been started, wait until the looper has been created.
 synchronized (this) {
 while (isAlive() && mLooper == null) {
 try {
 wait();
 } catch (InterruptedException e) {
 }
 }
 }
 return mLooper;
 }
 
 /**
 * Quits the handler thread's looper.
 * 
 * Causes the handler thread's looper to terminate without processing any
 * more messages in the message queue.
 * 
 * Any attempt to post messages to the queue after the looper is asked to quit will fail.
 * For example, the {@link Handler#sendMessage(Message)} method will return false.
 * 
 * Using this method may be unsafe because some messages may not be delivered
 * before the looper terminates. Consider using {@link #quitSafely} instead to ensure
 * that all pending work is completed in an orderly manner.
 * 
 *
 * @return True if the looper looper has been asked to quit or false if the
 * thread had not yet started running.
 *
 * @see #quitSafely
 */
 public boolean quit() {
 Looper looper = getLooper();
 if (looper != null) {
 looper.quit();
 return true;
 }
 return false;
 }
 
 /**
 * Quits the handler thread's looper safely.
 * 
 * Causes the handler thread's looper to terminate as soon as all remaining messages
 * in the message queue that are already due to be delivered have been handled.
 * Pending delayed messages with due times in the future will not be delivered.
 * 
 * Any attempt to post messages to the queue after the looper is asked to quit will fail.
 * For example, the {@link Handler#sendMessage(Message)} method will return false.
 * 
 * If the thread has not been started or has finished (that is if
 * {@link #getLooper} returns null), then false is returned.
 * Otherwise the looper is asked to quit and true is returned.
 * 
 *
 * @return True if the looper looper has been asked to quit or false if the
 * thread had not yet started running.
 */
 public boolean quitSafely() {
 Looper looper = getLooper();
 if (looper != null) {
 looper.quitSafely();
 return true;
 }
 return false;
 }
 
 /**
 * Returns the identifier of this thread. See Process.myTid().
 */
 public int getThreadId() {
 return mTid;
 }
 }

从上面代码可以看出，HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，然后实现了Looper的实现，这是Handler消息机制必不可少的。有了自己的looper,可以让我们在自己的线程中分发和处理消息。

我们看run()方法，可以看到该方法中调用了Looper.prepare()，Loop.loop();

prepare()中创建了一个Looper对象，并且把该对象放到了该线程范围内的变量中（sThreadLocal），在Looper对象的构造过程中，初始化了一个MessageQueue，作为该Looper对象成员变量。

loop()表示开启工作，不断的循环从MessageQueue中取消息处理了，当没有消息的时候会阻塞，有消息的到来的时候会唤醒。

run方法里面当mLooper创建完成后有个notifyAll()，getLooper()中有个wait()，这是为什么呢？因为的mLooper在一个线程中执行，而我们的handler是在UI线程初始化的，也就是说，我们必须等到mLooper创建完成，才能正确的返回getLooper();wait(),notify()就是为了解决这两个线程的同步问题。

HandlerThread的使用方法还是比较简单的，但是我们要明白一点的是：如果一个线程要处理消息，那么它必须拥有自己的Looper，并不是Handler在哪里创建，就可以在哪里处理消息的。

如果不用HandlerThread的话，需要手动去调用Looper.prepare()和Looper.loop()这些方法。