Android中的Handler机制

╰+哭是因爲堅強的太久メ 2022-08-06 14:22 141阅读 0赞

还记得第一次使用Handler的情形，我开启了一个子线程，在子线程中给TextView进行setText()，然后运行起来程序异常终止了，查看log信息：

E/AndroidRuntime(2206): android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

goolgle一下找到了原因: 原来android中相关的view和控件不是线程安全的，我们必须单独做处理。然后就了解了Handler。可以在子线程中通过Handler发送一个Message给主线程，然后在主线程进行UI更新

![SouthEast][]

可以大概看成Handler的作用有分发消息，处理消息，发送消息，移除消息

下面看一下Message类

![SouthEast 1][]

可见Message包括what(message的标识) 、obj 任意对象， arg1 arg2, 而且可以设置Target来指定Handler

当Handler发送一条Message时有一下两种写法：

Message msg = Message.obtain();
    msg.what = 200;
    msg.obj = obj;
    handler.sendMessage(msg);

Message.obtain(handler, 200).sendToTarget();

Looper类：

![SouthEast 2][]

Looper的类注释中

Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one, call prepare in the thread that is to run the loop, and then loop to have it process messages until the loop is stopped. 
    
    Most interaction with a message loop is through the Handler class. 
    
    This is a typical example of the implementation of a Looper thread, using the separation of prepare and loop to create an initial Handler to communicate with the Looper. 
    
      class LooperThread extends Thread {
          public Handler mHandler;
    
          public void run() {
              Looper.prepare();
    
              mHandler = new Handler() {
                  public void handleMessage(Message msg) {
                      // process incoming messages here
                  }
              };
    
              Looper.loop();
          }
      }

##### Handler的作用？ #####

1)在非UI线程更新UI ;

2)发送一个延时消息;

3)当做定时器，每隔一段时间发送一次消息，如进行图片轮播

##### 为什么android设计只能UI线程更新UI？ #####

1) 解决多线程并发的问题  
2) 提高界面更新的性能问题  
3) 架构设计的简单

##### Handler 相关的异常 #####

1)E/AndroidRuntime(2206): android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

不能子线程更新UI的异常\{解决：在子线程向主线程中的handler发送Message\}

2E/AndroidRuntime(2329): java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()

不能在子线程中new Handlder()，我们需要调用Looper.prepare(); 后new Handler然后 Looper.loop();

**我们自己创建的线程中没有Looper对象，这里注意一点，在ActivityThread线I程中会隐士的调用Looper.prepare（）方法**

在下面我们会看一下Looper.prepare()方法的源码

##### Handler、Looper、MessageQueue之间的关系（源码角度分析）？ #####

Handler 的构造方法：

/**
         * Use the {@link Looper} for the current thread with the specified callback interface
         * and set whether the handler should be asynchronous.
         *
         * Handlers are synchronous by default unless this constructor is used to make
         * one that is strictly asynchronous.
         *
         * Asynchronous messages represent interrupts or events that do not require global ordering
         * with represent to synchronous messages.  Asynchronous messages are not subject to
         * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.
         *
         * @param callback The callback interface in which to handle messages, or null.
         * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for
         * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
         *
         * @hide
         */
        public Handler(Callback callback, boolean async) {
            if (FIND_POTENTIAL_LEAKS) {
                final Class<? extends Handler> klass = getClass();
                if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                        (klass.getModifiers() & Modifier.STATIC) == 0) {
                    Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                        klass.getCanonicalName());
                }
            }
            //获取Looper
            mLooper = Looper.myLooper();
            if (mLooper == null) {
                throw new RuntimeException(
                    "Can't create handler inside thread that has not called Looper.prepare()");
            }
            mQueue = mLooper.mQueue; //获取Looper中的MessageQueue
            mCallback = callback;
            mAsynchronous = async;
        }

</pre>Looper.myLooper();</div><div><pre name="code" class="java"> /**
         * Return the Looper object associated with the current thread.  Returns
         * null if the calling thread is not associated with a Looper.
         */
        public static Looper myLooper() {
            return sThreadLocal.get();
        }

final MessageQueue mQueue;

而Handler的各种sendMessage方法最终都会调用sendMessageAtTime(Message msg, long uptimeMillis)

/**
         * Enqueue a message into the message queue after all pending messages
         * before the absolute time (in milliseconds) <var>uptimeMillis</var>.
         * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>
         * Time spent in deep sleep will add an additional delay to execution.
         * You will receive it in {@link #handleMessage}, in the thread attached
         * to this handler.
         * 
         * @param uptimeMillis The absolute time at which the message should be
         *         delivered, using the
         *         {@link android.os.SystemClock#uptimeMillis} time-base.
         *         
         * @return Returns true if the message was successfully placed in to the 
         *         message queue.  Returns false on failure, usually because the
         *         looper processing the message queue is exiting.  Note that a
         *         result of true does not mean the message will be processed -- if
         *         the looper is quit before the delivery time of the message
         *         occurs then the message will be dropped.
         */
        public boolean 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 false;
            }
            return enqueueMessage(queue, msg, uptimeMillis); //将msg入队到mQueue中
        }

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
            msg.target = this;
            if (mAsynchronous) {
                msg.setAsynchronous(true);
            }
            return queue.enqueueMessage(msg, uptimeMillis);
        }

消息入队时将msg.target 制定成this，也就是Handler自身

可以看成当我们new Handlder时回从ThreadLocal中get一个Looper对象，而Looper中含有一个消息队列MessageQueue,当我们调用Handler的sendMessageXXX等方法时，会将一个Message对象添加到Looper的MessageQueue中，那么Looper中是如何处理Message的呢

Looper的构造方法： 可以看成这里会new一个MessageQueue对象，然后mThread为当前线程

private Looper(boolean quitAllowed) {
            mQueue = new MessageQueue(quitAllowed);
            mThread = Thread.currentThread();
        }

Looper. prepare()方法，因为Looper的构造方法是私有，Handler调用mThreadLocal.get()方法来获得Looper对象，而Looper的prepare方法中会new一个Looper放到mThreadLocal中

/** Initialize the current thread as a looper. 初始化一个looper
          * This gives you a chance to create handlers that then reference 该方法提供给用户一个机会去创建handler来
          * this looper, before actually starting the loop. Be sure to call
          * {@link #loop()} after calling this method, and end it by calling
          * {@link #quit()}.
          */
        public static void prepare() {
            prepare(true);
        }
    
        private 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));
        }

我们查看Looper的Loop方法

/**
         * Run the message queue in this thread. Be sure to call
         * {@link #quit()} to end the 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;
    
            // Make sure the identity of this thread is that of the local process,
            // and keep track of what that identity token actually is.
            Binder.clearCallingIdentity();
            final long ident = Binder.clearCallingIdentity();
    
            for (;;) {//一个死循环
                Message msg = queue.next(); // might block //不断获取下一个Message
                if (msg == null) { //当队列为空时msg为null 跳出循环
                    // No message indicates that the message queue is quitting.
                    return;
                }
    
                // This must be in a local variable, in case a UI event sets the logger
                Printer logging = me.mLogging;
                if (logging != null) {
                    logging.println(">>>>> Dispatching to " + msg.target + " " +
                            msg.callback + ": " + msg.what);
                }
    
                msg.target.dispatchMessage(msg); //这里调用msg.target（也就是handler）的<span style="font-family: Arial, Helvetica, sans-serif;"></span>dispatchMessage(msg);
                if (logging != null) {
                    logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
                }
    
                // Make sure that during the course of dispatching the
                // identity of the thread wasn't corrupted.
                final long newIdent = Binder.clearCallingIdentity();
                if (ident != newIdent) {
                    Log.wtf(TAG, "Thread identity changed from 0x"
                            + Long.toHexString(ident) + " to 0x"
                            + Long.toHexString(newIdent) + " while dispatching to "
                            + msg.target.getClass().getName() + " "
                            + msg.callback + " what=" + msg.what);
                }
    
                msg.recycleUnchecked();
            }
        }

这里调用msg.target（也就是handler）的dispatchMessage(msg); 我们来看handler的dispatchMessage方法

/**
         * Handle system messages here.
         */
        public void dispatchMessage(Message msg) {
            if (msg.callback != null) {
                handleCallback(msg);
            } else {
                if (mCallback != null) {
                    if (mCallback.handleMessage(msg)) {
                        return;
                    }
                }
                handleMessage(msg);
            }
        }

可以看到最终会回调执行我们熟悉的 handleMessage(msg);

1).Looper 内部包含一个消息队列 MessageQueue，suoyoudeHandler发送的消息都走向这个消息队列Looper.Looper方法，一个死循环，不断从MessageQueue取消息，有消息就处理，没有就阻塞

2).MessageQueue一个消息队列，可以添加消息，并处理消息  
3).Handler Handler封装了消息的发送（主要包括消息发送的对象，如何处理）内部跟Looper相关联，也就是说在handler的内部可以找到Looper然后可以获得Message，在Handler中发送消息，其实是向MessageQueue队列中发送消息  
  
总结：handler负责发送消息，Looper负责接受Handler发送来的消息，并把消息回传给handler自己，MessageQueue是一个存储消息的容器

![SouthEast 3][]

结合图片看看这个过程

[SouthEast]: /images/20220806/687f4b184eb3470db2fd2b69b14292ef.png
[SouthEast 1]: /images/20220806/783d418d5cdb4a268b211120060e7ccf.png
[SouthEast 2]: /images/20220806/5fd9b6a060de4487845833318ad82875.png
[SouthEast 3]: /images/20220806/90a5f799d5624b7c83f1831b8cbc2507.png