Android进阶之Handle和Looper消息机制原理和源码分析（不走弯路）

[[417195]]

本文转载自微信公众号「Android开发编程」，作者Android开发编程 。转载本文请联系Android开发编程公众号。

创新互联公司是专业的瓯海网站建设公司，瓯海接单;提供成都网站制作、成都做网站,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行瓯海网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

前言

App中一般多会有多个线程，多线程之间难免需要进行通信。在我们平时开发中线程通信用的最多的就是handler，例如子线程进行数据处理，在主线程中进行UI更新。

当然了除了Handler这种通信方式外，线程间的通信还有其他几种方式：管道Pip、共享内存、通过文件及数据库等。

我们主要来看下Handler以及其实现原理

一、looper死循环详解

1、死循环为什么不会导致应用卡死ANR

线程默认没有Looper的，如果需要使用Handler就必须为线程创建Looper。

我们经常提到的主线程，也叫UI线程，它就是ActivityThread，ActivityThread被创建时就会初始化Looper，这也是在主线程中默认可以使用Handler的原因。

  
 
 
 
    
   
  
  
  
  1. public static void main(String[] args) { 
    2. 
   
  
  
  
  2.     Looper.prepareMainLooper();//创建Looper和MessageQueue对象，用于处理主线程的消息 
    3. 
   
  
  
  
  3.     ActivityThread thread = new ActivityThread(); 
    4. 
   
  
  
  
  4.     thread.attach(false);//建立Binder通道 (创建新线程) 
    5. 
   
  
  
  
  5.     if (sMainThreadHandler == null) { 
    6. 
   
  
  
  
  6.         sMainThreadHandler = thread.getHandler(); 
    7. 
   
  
  
  
  7.     } 
    8. 
   
  
  
  
  8.     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); 
    9. 
   
  
  
  
  9.     Looper.loop(); 
    10. 
   
  
  
  
  10.     //如果能执行下面方法，说明应用崩溃或者是退出了... 
    11. 
   
  
  
  
  11.     throw new RuntimeException("Main thread loop unexpectedly exited"); 
    12. 
   
  
  
  
  12. } 
    13.

这个死循环会不会导致应用卡死，即使不会的话，它会慢慢的消耗越来越多的资源吗?

①对于线程即是一段可执行的代码，当可执行代码执行完成后，线程生命周期便该终止了，线程退出。而对于主线程，我们是绝不希望会被运行一段时间，自己就退出，那么如何保证能一直存活呢?简单做法就是可执行代码是能一直执行下去的，死循环便能保证不会被退出，例如，binder线程也是采用死循环的方法，通过循环方式不同与Binder驱动进行读写操作，当然并非简单地死循环，无消息时会休眠。但这里可能又引发了另一个问题，既然是死循环又如何去处理其他事务呢?通过创建新线程的方式。真正会卡死主线程的操作是在回调方法onCreate/onStart/onResume等操作时间过长，会导致掉帧，甚至发生ANR，looper.loop本身不会导致应用卡死。

②主线程的死循环一直运行是不是特别消耗CPU资源呢?其实不然，这里就涉及到Linux pipe/epoll机制，简单说就是在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源

2、主线程的消息循环机制是什么

主线程进入死循环之前便创建了新binder线程，在代码ActivityThread.main()中：

  
 
 
 
    
   
  
  
  
  1. public static void main(String[] args) { 
    2. 
   
  
  
  
  2. //创建Looper和MessageQueue对象，用于处理主线程的消息 
    3. 
   
  
  
  
  3.  Looper.prepareMainLooper(); 
    4. 
   
  
  
  
  4.  //创建ActivityThread对象 
    5. 
   
  
  
  
  5.  ActivityThread thread = new ActivityThread();  
    6. 
   
  
  
  
  6.  //建立Binder通道 (创建新线程) 
    7. 
   
  
  
  
  7.  thread.attach(false); 
    8. 
   
  
  
  
  8.  Looper.loop(); //消息循环运行 
    9. 
   
  
  
  
  9.  throw new RuntimeException("Main thread loop unexpectedly exited"); 
    10. 
   
  
  
  
  10. } 
    11.
  • Activity的生命周期都是依靠主线程的Looper.loop，当收到不同Message时则采用相应措施：一旦退出消息循环，那么你的程序也就可以退出了。从消息队列中取消息可能会阻塞，取到消息会做出相应的处理。如果某个消息处理时间过长，就可能会影响UI线程的刷新速率，造成卡顿的现象。
  • thread.attach(false)方法函数中便会创建一个Binder线程(具体是指ApplicationThread，Binder的服务端，用于接收系统服务AMS发送来的事件)，该Binder线程通过Handler将Message发送给主线程。「Activity 启动过程」比如收到msg=H.LAUNCH_ACTIVITY，则调用ActivityThread.handleLaunchActivity()方法，最终会通过反射机制，创建Activity实例，然后再执行Activity.onCreate()等方法;
  • 再比如收到msg=H.PAUSE_ACTIVITY，则调用ActivityThread.handlePauseActivity()方法，最终会执行Activity.onPause()等方法。
  • 主线程的消息又是哪来的呢?当然是App进程中的其他线程通过Handler发送给主线程

二、Handler机制原理详解

Handler机制，主要牵涉到的类有如下四个，它们分工明确，但又相互作用

Message：消息

Hanlder：消息的发起者

Looper：消息的遍历者

MessageQueue：消息队列

1、 Looper.prepare()

  
 
 
 
    
   
  
  
  
  1. public static void prepare() { 
    2. 
   
  
  
  
  2.         prepare(true); 
    3. 
   
  
  
  
  3.     } 
    4. 
   
  
  
  
  4.     private static void prepare(boolean quitAllowed) { 
    5. 
   
  
  
  
  5.         // 规定了一个线程只有一个Looper，也就是一个线程只能调用一次Looper.prepare() 
    6. 
   
  
  
  
  6.         if (sThreadLocal.get() != null) { 
    7. 
   
  
  
  
  7.             throw new RuntimeException("Only one Looper may be created per thread"); 
    8. 
   
  
  
  
  8.         } 
    9. 
   
  
  
  
  9.         // 如果当前线程没有Looper，那么就创建一个，存到sThreadLocal中 
    10. 
   
  
  
  
  10.         sThreadLocal.set(new Looper(quitAllowed)); 
    11. 
   
  
  
  
  11.     } 
    12.

从上面的代码可以看出，一个线程最多只有一个Looper对象。当没有Looper对象时，去创建一个Looper，并存放到sThreadLocal中，sThreadLocal是一个static的ThreadLocal对象，关于它的详细使用，以后有机会再介绍，这里只要知道，它存储了Looper对象的副本，并且可以通过它取得当前线程在之前存储的Looper的副本。如下图：

接下来看Looper的构造方法：

  
 
 
 
    
   
  
  
  
  1. private Looper(boolean quitAllowed) { 
    2. 
   
  
  
  
  2.         // 创建了MessageQueue，并供Looper持有 
    3. 
   
  
  
  
  3.         mQueue = new MessageQueue(quitAllowed); 
    4. 
   
  
  
  
  4.         // 让Looper持有当前线程对象 
    5. 
   
  
  
  
  5.         mThread = Thread.currentThread(); 
    6. 
   
  
  
  
  6.     } 
    7.

这里主要就是创建了消息队列MessageQueue，并让它供Looper持有，因为一个线程最大只有一个Looper对象，所以一个线程最多也只有一个消息队列。然后再把当前线程赋值给mThread。

MessageQueue的构造方法没有什么可讲的，它就是一个消息队列，用于存放Message。

所以Looper.prepare()的作用主要有以下三点：

  • 创建Looper对象
  • 创建MessageQueue对象，并让Looper对象持有
  • 让Looper对象持有当前线程

2、new Handler()

Handler有很多构造方法，主要是提供自定义Callback、Looper等，我们先从最简单的无参构造方法看起：

  
 
 
 
    
   
  
  
  
  1. public Handler() { 
    2. 
   
  
  
  
  2.         this(null, false); 
    3. 
   
  
  
  
  3.     } 
    4. 
   
  
  
  
  4.     public Handler(Callback callback, boolean async) { 
    5. 
   
  
  
  
  5.       // 不相关代码 
    6. 
   
  
  
  
  6.        ...... 
    7. 
   
  
  
  
  7.         //得到当前线程的Looper，其实就是调用的sThreadLocal.get 
    8. 
   
  
  
  
  8.         mLooper = Looper.myLooper(); 
    9. 
   
  
  
  
  9.         // 如果当前线程没有Looper就报运行时异常 
    10. 
   
  
  
  
  10.         if (mLooper == null) { 
    11. 
   
  
  
  
  11.             throw new RuntimeException( 
    12. 
   
  
  
  
  12.                 "Can't create handler inside thread that has not called Looper.prepare()"); 
    13. 
   
  
  
  
  13.         } 
    14. 
   
  
  
  
  14.         // 把得到的Looper的MessagQueue让Handler持有 
    15. 
   
  
  
  
  15.         mQueue = mLooper.mQueue; 
    16. 
   
  
  
  
  16.         // 初始化Handler的Callback，其实就是最开始图中的回调方法的2 
    17. 
   
  
  
  
  17.         mCallback = callback; 
    18. 
   
  
  
  
  18.         mAsynchronous = async; 
    19. 
   
  
  
  
  19.     } 
    20.

首先，调用了Looper.myLooper，其实就是调用sThreadLocal.get方法，会得到当前线程调用sThreadLocal.set保存的Looper对象，让Handler持有它。接下来就会判断得到的Looper对象是否为空，如果为空，就会报

"Can't create handler inside thread that has not called Looper.prepare()，这不就是我们之前在没有调用Looper.prepare就在子线程中创建Handler时报的错误嘛。的确，当我们没有调用Looper.prepare()，则当前线程中是没有Looper对象的。

然后，让Handler持有得到的Looper对象的MessageQueue和设置处理回调的Callback对象(最开始图中的回调方法2)。

到这里，默认的Handler的创建过程就结束了，主要有以下几点：

  • 创建Handler对象
  • 得到当前线程的Looper对象，并判断是否为空
  • 让创建的Handler对象持有Looper、MessageQueu、Callback的引用

3、Looper.loop()

  
 
 
 
    
   
  
  
  
  1. public static void loop() { 
    2. 
   
  
  
  
  2.         // 得到当前线程的Looper对象 
    3. 
   
  
  
  
  3.         final Looper me = myLooper(); 
    4. 
   
  
  
  
  4.         if (me == null) { 
    5. 
   
  
  
  
  5.             throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); 
    6. 
   
  
  
  
  6.         } 
    7. 
   
  
  
  
  7.         // 得到当前线程的MessageQueue对象 
    8. 
   
  
  
  
  8.         final MessageQueue queue = me.mQueue; 
    9. 
   
  
  
  
  9.         // 无关代码 
    10. 
   
  
  
  
  10.         ...... 
    11. 
   
  
  
  
  11.         // 死循环 
    12. 
   
  
  
  
  12.         for (;;) { 
    13. 
   
  
  
  
  13.             // 不断从当前线程的MessageQueue中取出Message，当MessageQueue没有元素时，方法阻塞 
    14. 
   
  
  
  
  14.             Message msg = queue.next(); // might block 
    15. 
   
  
  
  
  15.             if (msg == null) { 
    16. 
   
  
  
  
  16.                 // No message indicates that the message queue is quitting. 
    17. 
   
  
  
  
  17.                 return; 
    18. 
   
  
  
  
  18.             } 
    19. 
   
  
  
  
  19.             // Message.target是Handler，其实就是发送消息的Handler，这里就是调用它的dispatchMessage方法 
    20. 
   
  
  
  
  20.             msg.target.dispatchMessage(msg); 
    21. 
   
  
  
  
  21.             // 回收Message 
    22. 
   
  
  
  
  22.             msg.recycleUnchecked(); 
    23. 
   
  
  
  
  23.         } 
    24. 
   
  
  
  
  24.     } 
    25.

首先还是判断了当前线程是否有Looper，然后得到当前线程的MessageQueue。接下来，就是最关键的代码了，写了一个死循环，不断调用MessageQueue的next方法取出MessageQueue中的Message，注意，当MessageQueue中没有消息时，next方法会阻塞，导致当前线程挂起，后面会讲到。

拿到Message以后，会调用它的target的dispatchMessage方法，这个target其实就是发送消息时用到的Handler。所以就是调用Handler的dispatchMessage方法，代码如下：

  
 
 
 
    
   
  
  
  
  1. public void dispatchMessage(Message msg) { 
    2. 
   
  
  
  
  2.         // 如果msg.callback不是null，则调用handleCallback 
    3. 
   
  
  
  
  3.         if (msg.callback != null) { 
    4. 
   
  
  
  
  4.             handleCallback(msg); 
    5. 
   
  
  
  
  5.         } else { 
    6. 
   
  
  
  
  6.             // 如果 mCallback不为空，则调用mCallback.handleMessage方法 
    7. 
   
  
  
  
  7.             if (mCallback != null) { 
    8. 
   
  
  
  
  8.                 if (mCallback.handleMessage(msg)) { 
    9. 
   
  
  
  
  9.                     return; 
    10. 
   
  
  
  
  10.                 } 
    11. 
   
  
  
  
  11.             } 
    12. 
   
  
  
  
  12.             // 调用Handler自身的handleMessage，这就是我们常常重写的那个方法 
    13. 
   
  
  
  
  13.             handleMessage(msg); 
    14. 
   
  
  
  
  14.         } 
    15. 
   
  
  
  
  15.     } 
    16.

可以看出，这个方法就是从MessageQueue中取出Message以后，进行分发处理。

首先，判断msg.callback是不是空，其实msg.callback是一个Runnable对象，是Handler.post方式传递进来的参数，后面会讲到。而hanldeCallback就是调用的Runnable的run方法。

然后，判断mCallback是否为空，这是一个Handler.Callback的接口类型，之前说了Handler有多个构造方法，可以提供设置Callback，如果这里不为空，则调用它的hanldeMessage方法，注意，这个方法有返回值，如果返回了true，表示已经处理 ，不再调用Handler的handleMessage方法;如果mCallback为空，或者不为空但是它的handleMessage返回了false，则会继续调用Handler的handleMessage方法，该方法就是我们经常重写的那个方法。

关于从MessageQueue中取出消息以后的分发，如下面的流程图所示：

所以Looper.loop的作用就是：

从当前线程的MessageQueue从不断取出Message，并调用其相关的回调方法。

4、发送消息

使用Handler发送消息主要有两种，一种是sendXXXMessage方式，还有一个postXXX方式，不过两种方式最后都会调用到sendMessageDelayed方法，所以我们就以最简单的sendMessage方法来分析。

我们先来看Handler的sendMessage方法：

  
 
 
 
    
   
  
  
  
  1. public final boolean sendMessage(Message msg) 
    2. 
   
  
  
  
  2. { 
    3. 
   
  
  
  
  3.         return sendMessageDelayed(msg, 0); 
    4. 
   
  
  
  
  4.     } 
    5. 
   
  
  
  
  5.     public final boolean sendMessageDelayed(Message msg, long delayMillis) 
    6. 
   
  
  
  
  6. { 
    7. 
   
  
  
  
  7.         if (delayMillis < 0) { 
    8. 
   
  
  
  
  8.             delayMillis = 0; 
    9. 
   
  
  
  
  9.         } 
    10. 
   
  
  
  
  10.         return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); 
    11. 
   
  
  
  
  11.     } 
    12. 
   
  
  
  
  12.     public boolean sendMessageAtTime(Message msg, long uptimeMillis) { 
    13. 
   
  
  
  
  13.         // 这里拿到的MessageQueue其实就是创建时的MessageQueue，默认情况是当前线程的Looper对象的MessageQueue 
    14. 
   
  
  
  
  14.         // 也可以指定 
    15. 
   
  
  
  
  15.         MessageQueue queue = mQueue; 
    16. 
   
  
  
  
  16.         if (queue == null) { 
    17. 
   
  
  
  
  17.             RuntimeException e = new RuntimeException( 
    18. 
   
  
  
  
  18.                     this + " sendMessageAtTime() called with no mQueue"); 
    19. 
   
  
  
  
  19.             Log.w("Looper", e.getMessage(), e); 
    20. 
   
  
  
  
  20.             return false; 
    21. 
   
  
  
  
  21.         } 
    22. 
   
  
  
  
  22.         // 调用enqueueMessage，把消息加入到MessageQueue中 
    23. 
   
  
  
  
  23.         return enqueueMessage(queue, msg, uptimeMillis); 
    24. 
   
  
  
  
  24.     } 
    25. 
   
  
  
  
  25. 主要实现是调用enqueueMessage来实现的，看看该方法： 
    26. 
   
  
  
  
  26.     private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { 
    27. 
   
  
  
  
  27.         // 把当前Handler对象，也就是发起消息的handler作为Message的target属性 
    28. 
   
  
  
  
  28.         msg.target = this; 
    29. 
   
  
  
  
  29.         if (mAsynchronous) { 
    30. 
   
  
  
  
  30.             msg.setAsynchronous(true); 
    31. 
   
  
  
  
  31.         } 
    32. 
   
  
  
  
  32.         // 调用MessageQueue中的enqueueMessage方法 
    33. 
   
  
  
  
  33.         return queue.enqueueMessage(msg, uptimeMillis); 
    34. 
   
  
  
  
  34.     } 
    35.

首先，把当前Handler作为Message的target属性，方便Looper从MessageQueue中取出Message时进行消息处理。然后调用了MessageQueue的enqueueMessage方法，把handler发送的消息加入到MessageQueue，供Looper去取出来处理。我们记下来看看。

MessageQueue的enqueueMessage方法：

  
 
 
 
    
   
  
  
  
  1. MessageQueue的enqueueMessage方法： 
    2. 
   
  
  
  
  2.    boolean enqueueMessage(Message msg, long when) { 
    3. 
   
  
  
  
  3.         if (msg.target == null) { 
    4. 
   
  
  
  
  4.             throw new IllegalArgumentException("Message must have a target."); 
    5. 
   
  
  
  
  5.         } 
    6. 
   
  
  
  
  6.         // 一个Message，只能发送一次 
    7. 
   
  
  
  
  7.         if (msg.isInUse()) { 
    8. 
   
  
  
  
  8.             throw new IllegalStateException(msg + " This message is already in use."); 
    9. 
   
  
  
  
  9.         } 
    10. 
   
  
  
  
  10.         synchronized (this) { 
    11. 
   
  
  
  
  11.             if (mQuitting) { 
    12. 
   
  
  
  
  12.                 IllegalStateException e = new IllegalStateException( 
    13. 
   
  
  
  
  13.                         msg.target + " sending message to a Handler on a dead thread"); 
    14. 
   
  
  
  
  14.                 Log.w("MessageQueue", e.getMessage(), e); 
    15. 
   
  
  
  
  15.                 msg.recycle(); 
    16. 
   
  
  
  
  16.                 return false; 
    17. 
   
  
  
  
  17.             } 
    18. 
   
  
  
  
  18.             // 标记Message已经使用了 
    19. 
   
  
  
  
  19.             msg.markInUse(); 
    20. 
   
  
  
  
  20.             msg.when = when; 
    21. 
   
  
  
  
  21.             // 得到当前消息队列的头部 
    22. 
   
  
  
  
  22.             Message p = mMessages; 
    23. 
   
  
  
  
  23.             boolean needWake; 
    24. 
   
  
  
  
  24.             // 我们这里when为0，表示立即处理的消息 
    25. 
   
  
  
  
  25.             if (p == null || when == 0 || when < p.when) { 
    26. 
   
  
  
  
  26.                 // 把消息插入到消息队列的头部 
    27. 
   
  
  
  
  27.                 msg.next = p; 
    28. 
   
  
  
  
  28.                 mMessages = msg; 
    29. 
   
  
  
  
  29.                 needWake = mBlocked; 
    30. 
   
  
  
  
  30.             } else { 
    31. 
   
  
  
  
  31.                 // 根据需要把消息插入到消息队列的合适位置，通常是调用xxxDelay方法，延时发送消息 
    32. 
   
  
  
  
  32.                 needWake = mBlocked && p.target == null && msg.isAsynchronous(); 
    33. 
   
  
  
  
  33.                 Message prev; 
    34. 
   
  
  
  
  34.                 for (;;) { 
    35. 
   
  
  
  
  35.                     prev = p; 
    36. 
   
  
  
  
  36.                     p = p.next; 
    37. 
   
  
  
  
  37.                     if (p == null || when < p.when) { 
    38. 
   
  
  
  
  38.                         break; 
    39. 
   
  
  
  
  39.                     } 
    40. 
   
  
  
  
  40.                     if (needWake && p.isAsynchronous()) { 
    41. 
   
  
  
  
  41.                         needWake = false; 
    42. 
   
  
  
  
  42.                     } 
    43. 
   
  
  
  
  43.                 } 
    44. 
   
  
  
  
  44.                 // 把消息插入到合适位置 
    45. 
   
  
  
  
  45.                 msg.next = p; // invariant: p == prev.next 
    46. 
   
  
  
  
  46.                 prev.next = msg; 
    47. 
   
  
  
  
  47.             } 
    48. 
   
  
  
  
  48.             // 如果队列阻塞了，则唤醒 
    49. 
   
  
  
  
  49.             if (needWake) { 
    50. 
   
  
  
  
  50.                 nativeWake(mPtr); 
    51. 
   
  
  
  
  51.             } 
    52. 
   
  
  
  
  52.         } 
    53. 
   
  
  
  
  53.         return true; 
    54. 
   
  
  
  
  54.     } 
    55.

首先，判断了Message是否已经使用过了，如果使用过，则直接抛出异常，这是可以理解的，如果MessageQueue中已经存在一个Message，但是还没有得到处理，这时候如果再发送一次该Message，可能会导致处理前一个Message时，出现问题。

然后，会判断when，它是表示延迟的时间，我们这里没有延时，所以为0，满足if条件。把消息插入到消息队列的头部。如果when不为0，则需要把消息加入到消息队列的合适位置。

最后会去判断当前线程是否已经阻塞了，如果阻塞了，则需要调用本地方法去唤醒它。

以上是sendMessage的全部过程，其实就是把Message加入到MessageQueue的合适位置。那我们来简单看看post系列方法：

  
 
 
 
    
   
  
  
  
  1. public final boolean post(Runnable r) 
    2. 
   
  
  
  
  2. { 
    3. 
   
  
  
  
  3.       return  sendMessageDelayed(getPostMessage(r), 0); 
    4. 
   
  
  
  
  4.    } 
    5. 
   
  
  
  
  5.    private static Message getPostMessage(Runnable r) { 
    6. 
   
  
  
  
  6.        // 构造一个Message，并让其callback执行传来的Runnable 
    7. 
   
  
  
  
  7.        Message m = Message.obtain(); 
    8. 
   
  
  
  
  8.        m.callback = r; 
    9. 
   
  
  
  
  9.        return m; 
    10. 
   
  
  
  
  10.    } 
    11.

可以看到，post方法只是先调用了getPostMessage方法，用Runnable去封装一个Message，然后就调用了sendMessageDelayed，把封装的Message加入到MessageQueue中。

所以使用handler发送消息的本质都是：把Message加入到Handler中的MessageQueue中去。

三、Handler 是如何能够线程切换

Handler创建的时候会采用当前线程的Looper来构造消息循环系统，Looper在哪个线程创建，就跟哪个线程绑定，并且Handler是在他关联的Looper对应的线程中处理消息的。

那么Handler内部如何获取到当前线程的Looper呢—–ThreadLocal。

ThreadLocal可以在不同的线程中互不干扰的存储并提供数据，通过ThreadLocal可以轻松获取每个线程的Looper。当然需要注意的是:

①线程是默认没有Looper的，如果需要使用Handler，就必须为线程创建Looper。我们经常提到的主线程，也叫UI线程，它就是ActivityThread;

②ActivityThread被创建时就会初始化Looper，这也是在主线程中默认可以使用Handler的原因。

系统为什么不允许在子线程中访问UI?这是因为Android的UI控件不是线程安全的，如果在多线程中并发访问可能会导致UI控件处于不可预期的状态，那么为什么系统不对UI控件的访问加上锁机制呢?缺点有两个：①首先加上锁机制会让UI访问的逻辑变得复杂 ②锁机制会降低UI访问的效率，因为锁机制会阻塞某些线程的执行。所以最简单且高效的方法就是采用单线程模型来处理UI操作。

四、Handler造成内存泄露

1、引起内存泄露原因

Java使用有向图机制，通过GC自动检查内存中的对象(什么时候检查由虚拟机决定)，如果GC发现一个或一组对象为不可到达状态，则将该对象从内存中回收。也就是说，一个对象不被任何引用所指向，则该对象会在被GC发现的时候被回收;另外，如果一组对象中只包含互相的引用，而没有来自它们外部的引用(例如有两个对象A和B互相持有引用，但没有任何外部对象持有指向A或B的引用)，这仍然属于不可到达，同样会被GC回收。

Android中使用Handler造成内存泄露的原因

  
 
 
 
    
   
  
  
  
  1. Handler mHandler = new Handler() { 
    2. 
   
  
  
  
  2.     @Override 
    3. 
   
  
  
  
  3.     public void handleMessage(Message msg) { 
    4. 
   
  
  
  
  4.         mImageView.setImageBitmap(mBitmap); 
    5. 
   
  
  
  
  5.     } 
    6. 
   
  
  
  
  6. } 
    7.

上面是一段简单的Handler的使用。当使用内部类(包括匿名类)来创建Handler的时候，Handler对象会隐式地持有一个外部类对象(通常是一个Activity)的引用(不然你怎么可能通过Handler来操作Activity中的View?)。而Handler通常会伴随着一个耗时的后台线程(例如从网络拉取图片)一起出现，这个后台线程在任务执行完毕(例如图片下载完毕)之后，通过消息机制通知Handler，然后Handler把图片更新到界面。然而，如果用户在网络请求过程中关闭了Activity，正常情况下，Activity不再被使用，它就有可能在GC检查时被回收掉，但由于这时线程尚未执行完，而该线程持有Handler的引用(不然它怎么发消息给Handler?)，这个Handler又持有Activity的引用，就导致该Activity无法被回收(即内存泄露)，直到网络请求结束(例如图片下载完毕)。另外，如果你执行了Handler的postDelayed()方法，该方法会将你的Handler装入一个Message，并把这条Message推到MessageQueue中，那么在你设定的delay到达之前，会有一条MessageQueue -> Message -> Handler -> Activity的链，导致你的Activity被持有引用而无法被回收。

2、解决方法

①在关闭Activity的时候停掉你的后台线程。线程停掉了，就相当于切断了Handler和外部连接的线，Activity自然会在合适的时候被回收;

②如果你的Handler是被delay的Message持有了引用，那么使用相应的Handler的removeCallbacks()方法，把消息对象从消息队列移除就行了;

③将Handler声明为静态类，由于Handler不再持有外部类对象的引用，导致程序不允许你在Handler中操作Activity中的对象了。所以你需要在Handler中增加一个对Activity的弱引用(WeakReference)

  
 
 
 
    
   
  
  
  
  1. private static class MyHandler extends Handler {   
    2. 
   
  
  
  
  2.         WeakReference mActivity;   
    3. 
   
  
  
  
  3.         MyHandler(MainActivity mActivity){   
    4. 
   
  
  
  
  4.             this.mActivity = new WeakReference(mActivity);   
    5. 
   
  
  
  
  5.         }   
    6. 
   
  
  
  
  6.         @Override   
    7. 
   
  
  
  
  7.         public void handleMessage(Message msg) {   
    8. 
   
  
  
  
  8.             switch(msg.what){   
    9. 
   
  
  
  
  9.             case IMAGE_FAILURE:   
    10. 
   
  
  
  
  10.                 Toast.makeText(mActivity.get()   
    11. 
   
  
  
  
  11.                         , "Image Failure", Toast.LENGTH_LONG).show();   
    12. 
   
  
  
  
  12.                 break;           
    13. 
   
  
  
  
  13.             }   
    14. 
   
  
  
  
  14.         }   
    15. 
   
  
  
  
  15.     }  
    16.

总结

Handler消息机制主要的四个类的功能：

  • Message:信息的携带者，持有了Handler，存在MessageQueue中，一个线程可以有多个。
  • Hanlder:消息的发起者，发送Message以及消息处理的回调实现，一个线程可以有多个Handler对象。
  • Looper:消息的遍历者，从MessageQueue中循环取出Message进行处理，一个线程最多只有一个。
  • MessageQueue:消息队列，存放了Handler发送的消息，供Looper循环取消息，一个线程最多只有一个。

新闻名称：Android进阶之Handle和Looper消息机制原理和源码分析（不走弯路）
新闻来源：http://www.shufengxianlan.com/qtweb/news12/300162.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站排名知识

分类信息网

成都VI设计　　 　成都网络营销公司　　 　四川瑞杰　　 　网站改版　　 　app开发　　 　成都微信开发　　 　盐亭网站制作公司　　 　教育培训网站建设方案　　 　主机租用　　 　四川内江电信机房　　 　铁科精智测控　　 　成都网站优化　　 　高端网站建设　　 　成都茶叶销售　　 　温江网站设计　　 　重庆电信回兴机房　　 　攀枝花网站建设　　 　成都小程序开发　　 　成都画册制作　　 　重庆网站营销