Android Handler

Love The Way You Lie 2022-12-28 01:46 212阅读 0赞

关联文章:
Android多线程(Handler篇)
Android多线程(AsyncTask篇)
Android多线程(HandlerThread篇)
Android多线程(IntentService篇)

先放流程图：
这里写图片描述
由于Android中的耗时操作不能放入主线程中，所以实现多线程是必须的。今天的主角是Handler，本文将从使用及源码来分析探索其奥秘。

使用

步骤：

  1. 创建Handler对象，实现handlMessage()方法
  2. 创建Runnable线程
  3. 此时产生一个Looper，并自动创建一个消息队列MessageQueue()
  4. Looper轮询MessageQueue交给Handler
  5. Handler做处理

其中1、2、5为使用步骤，其他在后面分析源码时会讲到
使用方法

  1. public class MainActivity extends AppCompatActivity {
  2.     @SuppressLint("HandlerLeak")
  3.     Handler handler = new Handler(){
  4.         @Override
  5.         public void handleMessage(Message msg) {
  6.             super.handleMessage(msg);
  7.             switch (msg.what){
  8.                 case 1:
  9. //                    处理事件
  10.                     break;
  11.             }
  12.         }
  13.     };
  15.     @Override
  16.     protected void onCreate(Bundle savedInstanceState) {
  17.         super.onCreate(savedInstanceState);
  18.         setContentView(R.layout.activity_main);
  19.         new Thread(new Runnable() {
  20.             @Override
  21.             public void run() {
  22. //                耗时操作
  23.                 Message message = new Message();
  24.                 message.what = 1;
  25.                 handler.sendMessage(message);
  26.             }
  27.         }).start();
  28.     }
  29. }

使用就写这么多，接下来重点分析Handler原理。

原理分析

首先列一下将会讲到的几个对象

  1. ThreadLocal
  2. Looper
  3. MessageQueue
  4. Handler
  5. Message

ThreadLocal

关于他我看了几篇博客，很大一部分写的是错的，所以
注意：

  • 他并不是解决共享对象的多线程访问问题的！！！
  • 他并没有创建对象的拷贝或副本！！！

目的：他只是为了保证每个线程都拥有同一个类的不同对象
实质：每个线程里都new了同一个类的对象
作用：你或许觉得这样做很傻，但是如果使用全局变量就要考虑线程安全问题，而线程安全是以消耗性能为前提的，所以这种设计可以说很巧妙
场景：每个线程都需要相同类型的对象，又各自独立，并且与他相关的操作不少时，如，Looper，ActivityThread，AMS 等

  1. private static final ThreadLocal tSession = new ThreadLocal();
  2. public static Session getSession() throws Exception{
  3.     Session s = tSession.get();
  4.     try{
  5.         if(s==null){
  6.             s = getSessionFactory.openSession();
  7.             tSession.set(s);
  8.         }
  9.     }catch(Exception e){
  11.     }
  12.     return s;
  13. }

我们看一下ThreadLocal的源码，主要分析get()和set()

  1. public T get() {
  2.         Thread t = Thread.currentThread();
  3.         ThreadLocalMap map = getMap(t);
  4.         if (map != null) {
  5.             ThreadLocalMap.Entry e = map.getEntry(this);
  6.             if (e != null) {
  7.                 @SuppressWarnings("unchecked")
  8.                 T result = (T)e.value;
  9.                 return result;
  10.             }
  11.         }
  12.         return setInitialValue();
  13.     }
  15.     public void set(T value) {
  16.         Thread t = Thread.currentThread();
  17.         ThreadLocalMap map = getMap(t);
  18.         if (map != null)
  19.             map.set(this, value);
  20.         else
  21.             createMap(t, value);
  22.     }
  24.     ThreadLocalMap getMap(Thread t) {
  25.         return t.threadLocals;
  26.     }

set、get操作的都是ThreadLocalMap,key=当前线程，value=线程局部变量缓存值。可以看到get()实际上都是调用getMap(传入当前线程)来取得当前线程的ThreadLocalMap对象

  • set()，实际上是调用了ThreadLocalMap的set()，ThreadLocalMap的set()涉及到哈希散列算法，我会在之后博客里详细分析这里先不提算法的事。
  • get()，从当前线程中获取ThreadLocalMap，查询当前ThreadLocal变量实例对应的Entry，如果不为null，获取value，如果map为null，走初始化方法

由此看出不是如很多博主写的各线程用了同一个对象又相互独立那么神奇，只不过是用线程当做键在其中维护了一个私有变量而已。得到ThreadLocalMap后如何得到维护的变量呢，在这一句

ThreadLocalMap.Entry e = map.getEntry(this);
//this指代的ThreadLocal对象

所以过程就很清晰了，我们来总结一下：

  1. 声明一个全局公用的ThreadLocal实例作为key
  2. 在线程中new一个或取出已经存了的对象作为value
  3. 将此key-value放入ThreadLocalMap中
  4. 将当前线程作为key，ThreadLocalMap作为值放入ThreadLocal中

比较绕多读几遍就能明白了，再放一张图加深理解
这里写图片描述

Looper

两件事

  1. 创建消息队列
  2. 在队列中循环取消息

两个方法

  1. prepare()
  2. loop()

两个作用

  1. 保证当前线程只有一个looper和一个MessageQueue
  2. 从MessageQueue中取消息交给target的dispatchMessage

下面我们分析源码

#####构造方法

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

很容易看出当Looper构造时创建了一个消息队列

#####prepare()方法

  1. private static void prepare(boolean quitAllowed) {
  2.         if (sThreadLocal.get() != null) {
  3.             throw new RuntimeException("Only one Looper may be created per thread");
  4.         }
  5.         sThreadLocal.set(new Looper(quitAllowed));
  6.     }

通过前面ThreadLocal的分析可知sThreadLocal.get()得到了Looper对象，当Looper存在是报错，不存在是创建一个存入ThreadLocal中，保证线程里有且只有一个Looper对象。

#####loop()

  1. /**
  2.      * Run the message queue in this thread. Be sure to call
  3.      * {@link #quit()} to end the loop.
  4.      */
  5.     public static void loop() {
  6.         final Looper me = myLooper();
  7.         if (me == null) {
  8.             throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
  9.         }
  10.         final MessageQueue queue = me.mQueue;
  12.         // Make sure the identity of this thread is that of the local process,
  13.         // and keep track of what that identity token actually is.
  14.         Binder.clearCallingIdentity();
  15.         final long ident = Binder.clearCallingIdentity();
  17.         for (;;) {
  18.             Message msg = queue.next(); // might block
  19.             if (msg == null) {
  20.                 // No message indicates that the message queue is quitting.
  21.                 return;
  22.             }
  24.             // This must be in a local variable, in case a UI event sets the logger
  25.             final Printer logging = me.mLogging;
  26.             if (logging != null) {
  27.                 logging.println(">>>>> Dispatching to " + msg.target + " " +
  28.                         msg.callback + ": " + msg.what);
  29.             }
  31.             final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
  33.             final long traceTag = me.mTraceTag;
  34.             if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
  35.                 Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
  36.             }
  37.             final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
  38.             final long end;
  39.             try {
  40.                 msg.target.dispatchMessage(msg);
  41.                 end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
  42.             } finally {
  43.                 if (traceTag != 0) {
  44.                     Trace.traceEnd(traceTag);
  45.                 }
  46.             }
  47.             if (slowDispatchThresholdMs > 0) {
  48.                 final long time = end - start;
  49.                 if (time > slowDispatchThresholdMs) {
  50.                     Slog.w(TAG, "Dispatch took " + time + "ms on "
  51.                             + Thread.currentThread().getName() + ", h=" +
  52.                             msg.target + " cb=" + msg.callback + " msg=" + msg.what);
  53.                 }
  54.             }
  56.             if (logging != null) {
  57.                 logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
  58.             }
  60.             // Make sure that during the course of dispatching the
  61.             // identity of the thread wasn't corrupted.
  62.             final long newIdent = Binder.clearCallingIdentity();
  63.             if (ident != newIdent) {
  64.                 Log.wtf(TAG, "Thread identity changed from 0x"
  65.                         + Long.toHexString(ident) + " to 0x"
  66.                         + Long.toHexString(newIdent) + " while dispatching to "
  67.                         + msg.target.getClass().getName() + " "
  68.                         + msg.callback + " what=" + msg.what);
  69.             }
  71.             msg.recycleUnchecked();
  72.         }
  73.     }

1）拿到ThreadLocal中的Looper，若没有则prepare()
2）拿到Looper的MessageQueue
3）进入死循环，调用msg.target.dispatchMessage(msg)，发给Handler
4）释放资源

MessageQueue

一个单链表结构的消息队列

Handler

#####构造函数

  1. public Handler(Callback callback, boolean async) {
  2.         if (FIND_POTENTIAL_LEAKS) {
  3.             final Class<? extends Handler> klass = getClass();
  4.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
  5.                     (klass.getModifiers() & Modifier.STATIC) == 0) {
  6.                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
  7.                     klass.getCanonicalName());
  8.             }
  9.         }
  11.         mLooper = Looper.myLooper();
  12.         if (mLooper == null) {
  13.             throw new RuntimeException(
  14.                 "Can't create handler inside thread that has not called Looper.prepare()");
  15.         }
  16.         mQueue = mLooper.mQueue;
  17.         mCallback = callback;
  18.         mAsynchronous = async;
  19.     }

构造时通过Looper.myLooper获取当前线程保存的Looper实例，再获取这个Looper的MessageQueue

#####发送消息

  1. public final boolean sendMessage(Message msg)
  2.     {
  3.         return sendMessageDelayed(msg, 0);
  4.     }
  6.     /**
  7.      * Sends a Message containing only the what value.
  8.      *  
  9.      * @return Returns true if the message was successfully placed in to the 
  10.      *         message queue.  Returns false on failure, usually because the
  11.      *         looper processing the message queue is exiting.
  12.      */
  13.     public final boolean sendEmptyMessage(int what)
  14.     {
  15.         return sendEmptyMessageDelayed(what, 0);
  16.     }
  18.     /**
  19.      * Sends a Message containing only the what value, to be delivered
  20.      * after the specified amount of time elapses.
  21.      * @see #sendMessageDelayed(android.os.Message, long) 
  22.      * 
  23.      * @return Returns true if the message was successfully placed in to the 
  24.      *         message queue.  Returns false on failure, usually because the
  25.      *         looper processing the message queue is exiting.
  26.      */
  27.     public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
  28.         Message msg = Message.obtain();
  29.         msg.what = what;
  30.         return sendMessageDelayed(msg, delayMillis);
  31.     }

发送消息时所有方法都实际调用了sendMessageAtTime

  1. public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
  2.         MessageQueue queue = mQueue;
  3.         if (queue == null) {
  4.             RuntimeException e = new RuntimeException(
  5.                     this + " sendMessageAtTime() called with no mQueue");
  6.             Log.w("Looper", e.getMessage(), e);
  7.             return false;
  8.         }
  9.         return enqueueMessage(queue, msg, uptimeMillis);
  10.     }

是获取MessageQueue调用enqueueMessage();
#####接下来看enqueueMessage中

  1. private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
  2.         msg.target = this;
  3.         if (mAsynchronous) {
  4.             msg.setAsynchronous(true);
  5.         }
  6.         return queue.enqueueMessage(msg, uptimeMillis);
  7.     }

将msg的target属性赋值为Handler自己，实现了Message与Handler的绑定，并调用了MessageQueue中的enqueueMessage()方法

  1. boolean enqueueMessage(Message msg, long when) {
  2.         if (msg.target == null) {
  3.             throw new IllegalArgumentException("Message must have a target.");
  4.         }
  5.         if (msg.isInUse()) {
  6.             throw new IllegalStateException(msg + " This message is already in use.");
  7.         }
  9.         synchronized (this) {
  10.             if (mQuitting) {
  11.                 IllegalStateException e = new IllegalStateException(
  12.                         msg.target + " sending message to a Handler on a dead thread");
  13.                 Log.w(TAG, e.getMessage(), e);
  14.                 msg.recycle();
  15.                 return false;
  16.             }
  18.             msg.markInUse();
  19.             msg.when = when;
  20.             Message p = mMessages;
  21.             boolean needWake;
  22.             if (p == null || when == 0 || when < p.when) {
  23.                 // New head, wake up the event queue if blocked.
  24.                 msg.next = p;
  25.                 mMessages = msg;
  26.                 needWake = mBlocked;
  27.             } else {
  28.                 // Inserted within the middle of the queue.  Usually we don't have to wake
  29.                 // up the event queue unless there is a barrier at the head of the queue
  30.                 // and the message is the earliest asynchronous message in the queue.
  31.                 needWake = mBlocked && p.target == null && msg.isAsynchronous();
  32.                 Message prev;
  33.                 for (;;) {
  34.                     prev = p;
  35.                     p = p.next;
  36.                     if (p == null || when < p.when) {
  37.                         break;
  38.                     }
  39.                     if (needWake && p.isAsynchronous()) {
  40.                         needWake = false;
  41.                     }
  42.                 }
  43.                 msg.next = p; // invariant: p == prev.next
  44.                 prev.next = msg;
  45.             }
  47.             // We can assume mPtr != 0 because mQuitting is false.
  48.             if (needWake) {
  49.                 nativeWake(mPtr);
  50.             }
  51.         }
  52.         return true;
  53.     }

对前一个方法进行补充，把msg放入MessageQueue中，这时候轮询取消息(在前面Looper已经分析)，调用dispatchMessage()

  1. public void dispatchMessage(Message msg) {
  2.         if (msg.callback != null) {
  3.             handleCallback(msg);
  4.         } else {
  5.             if (mCallback != null) {
  6.                 if (mCallback.handleMessage(msg)) {
  7.                     return;
  8.                 }
  9.             }
  10.             handleMessage(msg);
  11.         }
  12.     }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

最终调用handlerMessage()方法

  1. /**
  2.      * Subclasses must implement this to receive messages.
  3.      */
  4.     public void handleMessage(Message msg) {
  5.     }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

一个空方法，在这里处理操作，end

##总结

  1. Looper.prepare()在本线程中存入ThreadLocalMap中一个Looper并创建一个MessageQueue对象
  2. Looper.loop()循环取Message中的消息，回调msg.target.dispatchMessage(msg)
  3. Handler构造得到Looper并与MessageQueue关联
  4. Handler.sendMessage会给msg.target赋值为自己并加入MessageQueue中
  5. 重写handlMessage()处理

发表评论

表情：
评论列表 （有 0 条评论，212人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Android 的 Handler 总结

    <一> Handler的定义: 主要接受子线程发送的数据, 并用此数据配合主线程更新UI. 解释: 当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程

    心已赠人心已赠人/ 0 赞/ 216 阅读

    相关 android之handler

    Android程序中一些操作是不能放在activity中的，因为非常耗时，如下载过程。这时，需要使用handler，即重新启动一个与activity并行的线程，下面是使用han

    淩亂°似流年淩亂°似流年/ 0 赞/ 358 阅读