logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Android之Handler简单介绍

 好汉勃士 2021-10-28

今天我们的主角：Android消息机制——Handler

Handler是什么：

Android系统中线程间传递消息的一种机制

Handler作为这么重要的一种机制，虽然我们在使用的时候基本上只用到这一个类，但是还是有必要了解一下与之相关的类。

Message：消息的载体

MessageQueue：消息队列，负责存储消息

Handler：负责发送和处理消息（发送和处理不在同一个线程）

Looper：通过死循环来取出消息并且通知Handler处理

我们先通过代码来看看基本用法

  1. class AActivity : AppCompatActivity() {
  3.     private lateinit var handler: Handler
  5.     @SuppressLint('HandlerLeak')
  6.     override fun onCreate(savedInstanceState: Bundle?) {
  7.         super.onCreate(savedInstanceState)
  8.         setContentView(R.layout.activity_main)
  10.         handler = object : Handler() {
  11.             override fun handleMessage(msg: Message) {
  12.                 super.handleMessage(msg)
  13.                 Log.d('ZLog AActivity', '接收到消息: $msg')
  14.             }
  15.         }
  17.         Thread {
  18.             kotlin.run {
  19.                 val msg = Message()
  20.                 msg.what = 110
  21.                 msg.arg1 = 1
  22.                 msg.arg2 = 2
  23.                 msg.obj = 'obj'
  24.                 handler.sendMessage(msg)
  25.             }
  26.         }.start()
  27.     }
  28. }

AActivity: 接收到消息: { when=-57ms what=110 arg1=1 arg2=2 obj=obj target=com.example.androidteach.AActivity$onCreate$1 }

我们这里创建了一个handler并且重写了handleMessage方法，然后新建了一个线程，在线程中构建了一个消息并且发送。

Message有几个参数是我们可以直接使用的：

what：一般用来区分消息类型

arg1、arg2：这2个是int型，可以携带简单的参数

obj、setData：可以设置复杂的数据。

Handler的发送方法有几个：

sendEmptyMessage（int what）：系统帮我们构建一个message并且设置what参数然后发送

sendEmptyMessageAtTime(int what, long uptimeMillis) 在指定的时间发送消息

sendEmptyMessageDelayed(int what, long delayMillis)：延时发送消息

sendMessage(@NonNull Message msg)：发送普通消息

sendMessageAtTime(@NonNull Message msg, long uptimeMillis)：指定时间发送消息

sendMessageDelayed(@NonNull Message msg, long delayMillis)：延时发送消息

obtainMessage()：返回一个Message

基本的使用就这样就可以了，下面我们就来看看它的运行机制：

先来看看Handler：

查看handler的源码我们可以看到它还有几个带参数的构造方法：

  1.     public Handler() {
  2.         this(null, false);
  3.     }
  5.     public Handler(@Nullable Callback callback) {
  6.         this(callback, false);
  7.     }
  9.     public Handler(@NonNull Looper looper) {
  10.         this(looper, null, false);
  11.     }
  13.     public Handler(@NonNull Looper looper, @Nullable Callback callback) {
  14.         this(looper, callback, false);
  15.     }
  17.     @UnsupportedAppUsage
  18.     public Handler(boolean async) {
  19.         this(null, async);
  20.     }
  22.     public Handler(@Nullable Callback callback, boolean async) {
  23.         if (FIND_POTENTIAL_LEAKS) {
  24.             final Class<? extends Handler> klass = getClass();
  25.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
  26.                     (klass.getModifiers() & Modifier.STATIC) == 0) {
  27.                 Log.w(TAG, 'The following Handler class should be static or leaks might occur: ' +
  28.                     klass.getCanonicalName());
  29.             }
  30.         }
  32.         mLooper = Looper.myLooper();
  33.         if (mLooper == null) {
  34.             throw new RuntimeException(
  35.                 'Can't create handler inside thread ' + Thread.currentThread()
  36.                         + ' that has not called Looper.prepare()');
  37.         }
  38.         mQueue = mLooper.mQueue;
  39.         mCallback = callback;
  40.         mAsynchronous = async;
  41.     }
  44.     @UnsupportedAppUsage
  45.     public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
  46.         mLooper = looper;
  47.         mQueue = looper.mQueue;
  48.         mCallback = callback;
  49.         mAsynchronous = async;
  50.     }

其中主要的就2个，一个传了Callback，一个传了Looper。Callback为消息的回调接口，只有一个方法：

  1. public interface Callback {
  2.         /**
  3.          * @param msg A {@link android.os.Message Message} object
  4.          * @return True if no further handling is desired
  5.          */
  6.         boolean handleMessage(@NonNull Message msg);
  7. }

我们刚刚创建的handler并没有给任何参数，所以最后会调用传递callbac的构造方法，并且默认为空。

可以看到其中的mLooper默认取Looper.myLooper()

这里我们的Handler已经拿到了looper和messageQueue了。再来看看发送消息，通过刚刚的几个sendMessage方法最后调用的地方：

  1.     private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
  2.             long uptimeMillis) {
  3.         msg.target = this;
  4.         msg.workSourceUid = ThreadLocalWorkSource.getUid();
  6.         if (mAsynchronous) {
  7.             msg.setAsynchronous(true);
  8.         }
  9.         return queue.enqueueMessage(msg, uptimeMillis);
  10.     }

到这里我们可以看到，先给msg设置了一个target，就是一个handler对象，设置为了本身，然后就是将消息添加到队列中。

下面我们来看一下Looper：

通过刚刚的Handler构造方法中可以看到Looper有一个静态方法myLooper，我们先进入这个方法看看：

  1. public static @Nullable Looper myLooper() {
  2.         return sThreadLocal.get();
  3.     }

可以看到它用sThreadLocal.get返回的，sThreadLocal是一个ThreadLocal<Looper>的静态成员，ThreadLocal类简单说就是以线程为key来存储数据的结构，每个线程保存的数据互不影响，调用的get和set方法只对当前线程有效。

所以如果Looper在调用myLooper()之前没有设置过的话获取的会是空值。那为什么我们直接创建的Handler里面Looper并不是空？我们来找一下相关的设置方法：

我们看到一个prepare方法，调用了一个私有的prepare方法，在这里面设置Looper，并且在设置之前判断了当前线程是不是已经设置过了，如果设置过了就会抛出异常，提示一个线程只能创建一个Looper。

我们刚刚创建handler的时候并没有调用prepare方法，那我们就再调用一下看看，是不是当前的线程已经设置过了。

我们可以看到这里就报了刚刚看到的异常，提示第20行。所以在这之前这个方法已经被调用过了。那么是谁调用的呢？肯定是系统了，因为我们是直接在activity的onCreate方法中调用的，所以这里 是main线程，系统在启动apk的时候已经帮我们调用过了，这样我们就可以在这里直接创建Handler而不用再去单独调用一次Looper.prepare方法。

其实系统调用的应该不是Looper.prepare方法，应该是prepareMainLooper方法，大家看看下面的截图：

系统启动的时候就已经帮我们初始化好了主线程的Looper。如果是在子线程呢？就需要我们自己调用Looper.prepare方法了。

那么消息是在那里被取出来的呢？还是在Looper中，我们来看一个loop方法：

  1. public static void loop() {
  2.         final Looper me = myLooper();
  3.         if (me == null) {
  4.             throw new RuntimeException('No Looper; Looper.prepare() wasn't called on this thread.');
  5.         }
  6.         final MessageQueue queue = me.mQueue;
  8.         // Make sure the identity of this thread is that of the local process,
  9.         // and keep track of what that identity token actually is.
  10.         Binder.clearCallingIdentity();
  11.         final long ident = Binder.clearCallingIdentity();
  13.         // Allow overriding a threshold with a system prop. e.g.
  14.         // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
  15.         final int thresholdOverride =
  16.                 SystemProperties.getInt('log.looper.'
  17.                         + Process.myUid() + '.'
  18.                         + Thread.currentThread().getName()
  19.                         + '.slow', 0);
  21.         boolean slowDeliveryDetected = false;
  23.         for (;;) {
  24.             Message msg = queue.next(); // might block
  25.             if (msg == null) {
  26.                 // No message indicates that the message queue is quitting.
  27.                 return;
  28.             }
  30.             // This must be in a local variable, in case a UI event sets the logger
  31.             final Printer logging = me.mLogging;
  32.             if (logging != null) {
  33.                 logging.println('>>>>> Dispatching to ' + msg.target + ' ' +
  34.                         msg.callback + ': ' + msg.what);
  35.             }
  36.             // Make sure the observer won't change while processing a transaction.
  37.             final Observer observer = sObserver;
  39.             final long traceTag = me.mTraceTag;
  40.             long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
  41.             long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
  42.             if (thresholdOverride > 0) {
  43.                 slowDispatchThresholdMs = thresholdOverride;
  44.                 slowDeliveryThresholdMs = thresholdOverride;
  45.             }
  46.             final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
  47.             final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);
  49.             final boolean needStartTime = logSlowDelivery || logSlowDispatch;
  50.             final boolean needEndTime = logSlowDispatch;
  52.             if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
  53.                 Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
  54.             }
  56.             final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
  57.             final long dispatchEnd;
  58.             Object token = null;
  59.             if (observer != null) {
  60.                 token = observer.messageDispatchStarting();
  61.             }
  62.             long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);
  63.             try {
  64.                 msg.target.dispatchMessage(msg);
  65.                 if (observer != null) {
  66.                     observer.messageDispatched(token, msg);
  67.                 }
  68.                 dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
  69.             } catch (Exception exception) {
  70.                 if (observer != null) {
  71.                     observer.dispatchingThrewException(token, msg, exception);
  72.                 }
  73.                 throw exception;
  74.             } finally {
  75.                 ThreadLocalWorkSource.restore(origWorkSource);
  76.                 if (traceTag != 0) {
  77.                     Trace.traceEnd(traceTag);
  78.                 }
  79.             }
  80.             if (logSlowDelivery) {
  81.                 if (slowDeliveryDetected) {
  82.                     if ((dispatchStart - msg.when) <= 10) {
  83.                         Slog.w(TAG, 'Drained');
  84.                         slowDeliveryDetected = false;
  85.                     }
  86.                 } else {
  87.                     if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, 'delivery',
  88.                             msg)) {
  89.                         // Once we write a slow delivery log, suppress until the queue drains.
  90.                         slowDeliveryDetected = true;
  91.                     }
  92.                 }
  93.             }
  94.             if (logSlowDispatch) {
  95.                 showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, 'dispatch', msg);
  96.             }
  98.             if (logging != null) {
  99.                 logging.println('<<<<< Finished to ' + msg.target + ' ' + msg.callback);
  100.             }
  102.             // Make sure that during the course of dispatching the
  103.             // identity of the thread wasn't corrupted.
  104.             final long newIdent = Binder.clearCallingIdentity();
  105.             if (ident != newIdent) {
  106.                 Log.wtf(TAG, 'Thread identity changed from 0x'
  107.                         + Long.toHexString(ident) + ' to 0x'
  108.                         + Long.toHexString(newIdent) + ' while dispatching to '
  109.                         + msg.target.getClass().getName() + ' '
  110.                         + msg.callback + ' what=' + msg.what);
  111.             }
  112.             msg.recycleUnchecked();
  113.         }
  114.     }

代码比较长，其实我们只需要关注其中的for循环，这里的for循环没有设置任何条件，那么就是一个死循环，它就是在这里面通过消息队列取出的消息，还记得handler的发送方法吗？在发送的时候，给每个message都设置了一个target，就是handler本身。所以这里取出消息后调用了target的dispatchMessage来分发消息，最终会调用我们重写的handleMessage将消息给到我们自己处理。

到这里整个消息的传递流程就讲完了，说的比较乱，下面大致整理一下：

首先要了解的就是几个类的作用：

Handler：复制消息的发送和最终的处理；

Message：消息的实体，用来保存我们要传递的数据；

MessageQueue：消息队列，存储消息；

Looper：复制循环遍历取出消息并且分发给各自的Handler处理。相当于邮局分派信件，所以每个线程只能有一个Looper。

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 好汉勃士 > 《Java的基本概述》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多