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

前言

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

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

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

一、Looper死循环详解

图片

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

  • 线程默认没有Looper的,如果需要使用Handler就必须为线程创建Looper。
  • 我们经常提到的主线程,也叫UI线程,它就是ActivityThread,ActivityThread被创建时就会初始化Looper,这也是在主线程中默认可以使用Handler的原因。
  • ActivityThread,并且在main方法中我们会看到主线程也是通过Looper方式来维持一个消息循环
public static void main(String[] args) {    Looper.prepareMainLooper();//创建Looper和MessageQueue对象,用于处理主线程的消息    ActivityThread thread = new ActivityThread();    thread.attach(false);//建立Binder通道 (创建新线程)    if (sMainThreadHandler == null) {        sMainThreadHandler = thread.getHandler();    }    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);    Looper.loop();    //如果能执行下面方法,说明应用崩溃或者是退出了...    throw new RuntimeException("Main thread loop unexpectedly exited");}

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

①对于线程即是一段可执行的代码,当可执行代码执行完成后,线程生命周期便该终止了,线程退出。而对于主线程,我们是绝不希望会被运行一段时间,自己就退出,那么如何保证能一直存活呢?简单做法就是可执行代码是能一直执行下去的,死循环便能保证不会被退出,例如,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()中:

public static void main(String[] args) {//创建Looper和MessageQueue对象,用于处理主线程的消息 Looper.prepareMainLooper(); //创建ActivityThread对象 ActivityThread thread = new ActivityThread();  //建立Binder通道 (创建新线程) thread.attach(false); Looper.loop(); //消息循环运行 throw new RuntimeException("Main thread loop unexpectedly exited");}
  • 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()

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

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

图片
图片

接下来看Looper的构造方法:

 private Looper(boolean quitAllowed) {        // 创建了MessageQueue,并供Looper持有        mQueue = new MessageQueue(quitAllowed);        // 让Looper持有当前线程对象        mThread = Thread.currentThread();    }

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

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

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

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

2、new Handler()

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

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

首先,调用了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()

 public static void loop() {        // 得到当前线程的Looper对象        final Looper me = myLooper();        if (me == null) {            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");        }        // 得到当前线程的MessageQueue对象        final MessageQueue queue = me.mQueue;        // 无关代码        ......        // 死循环        for (;;) {            // 不断从当前线程的MessageQueue中取出Message,当MessageQueue没有元素时,方法阻塞            Message msg = queue.next(); // might block            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }            // Message.target是Handler,其实就是发送消息的Handler,这里就是调用它的dispatchMessage方法            msg.target.dispatchMessage(msg);            // 回收Message            msg.recycleUnchecked();        }    }

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

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

public void dispatchMessage(Message msg) {        // 如果msg.callback不是null,则调用handleCallback        if (msg.callback != null) {            handleCallback(msg);        } else {            // 如果 mCallback不为空,则调用mCallback.handleMessage方法            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            // 调用Handler自身的handleMessage,这就是我们常常重写的那个方法            handleMessage(msg);        }    }

可以看出,这个方法就是从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方法:

 public final boolean sendMessage(Message msg){        return sendMessageDelayed(msg, 0);    }    public final boolean sendMessageDelayed(Message msg, long delayMillis){        if (delayMillis < 0) {            delayMillis = 0;        }        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {        // 这里拿到的MessageQueue其实就是创建时的MessageQueue,默认情况是当前线程的Looper对象的MessageQueue        // 也可以指定        MessageQueue queue = mQueue;        if (queue == null) {            RuntimeException e = new RuntimeException(                    this + " sendMessageAtTime() called with no mQueue");            Log.w("Looper", e.getMessage(), e);            return false;        }        // 调用enqueueMessage,把消息加入到MessageQueue中        return enqueueMessage(queue, msg, uptimeMillis);    }主要实现是调用enqueueMessage来实现的,看看该方法:    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {        // 把当前Handler对象,也就是发起消息的handler作为Message的target属性        msg.target = this;        if (mAsynchronous) {            msg.setAsynchronous(true);        }        // 调用MessageQueue中的enqueueMessage方法        return queue.enqueueMessage(msg, uptimeMillis);    }

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

MessageQueue的enqueueMessage方法:   boolean enqueueMessage(Message msg, long when) {        if (msg.target == null) {            throw new IllegalArgumentException("Message must have a target.");        }        // 一个Message,只能发送一次        if (msg.isInUse()) {            throw new IllegalStateException(msg + " This message is already in use.");        }        synchronized (this) {            if (mQuitting) {                IllegalStateException e = new IllegalStateException(                        msg.target + " sending message to a Handler on a dead thread");                Log.w("MessageQueue", e.getMessage(), e);                msg.recycle();                return false;            }            // 标记Message已经使用了            msg.markInUse();            msg.when = when;            // 得到当前消息队列的头部            Message p = mMessages;            boolean needWake;            // 我们这里when为0,表示立即处理的消息            if (p == null || when == 0 || when < p.when) {                // 把消息插入到消息队列的头部                msg.next = p;                mMessages = msg;                needWake = mBlocked;            } else {                // 根据需要把消息插入到消息队列的合适位置,通常是调用xxxDelay方法,延时发送消息                needWake = mBlocked && p.target == null && msg.isAsynchronous();                Message prev;                for (;;) {                    prev = p;                    p = p.next;                    if (p == null || when < p.when) {                        break;                    }                    if (needWake && p.isAsynchronous()) {                        needWake = false;                    }                }                // 把消息插入到合适位置                msg.next = p; // invariant: p == prev.next                prev.next = msg;            }            // 如果队列阻塞了,则唤醒            if (needWake) {                nativeWake(mPtr);            }        }        return true;    }

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

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

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

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

  public final boolean post(Runnable r){      return  sendMessageDelayed(getPostMessage(r), 0);   }   private static Message getPostMessage(Runnable r) {       // 构造一个Message,并让其callback执行传来的Runnable       Message m = Message.obtain();       m.callback = r;       return m;   }

可以看到,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造成内存泄露的原因

Handler mHandler = new Handler() {    @Override    public void handleMessage(Message msg) {        mImageView.setImageBitmap(mBitmap);    }}

上面是一段简单的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)

private static class MyHandler extends Handler {          WeakReference<MainActivity> mActivity;          MyHandler(MainActivity mActivity){              this.mActivity = new WeakReference<MainActivity>(mActivity);          }          @Override          public void handleMessage(Message msg) {              switch(msg.what){              case IMAGE_FAILURE:                  Toast.makeText(mActivity.get()                          , "Image Failure", Toast.LENGTH_LONG).show();                  break;                      }          }      } 

总结

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

Message:信息的携带者,持有了Handler,存在MessageQueue中,一个线程可以有多个

Hanlder:消息的发起者,发送Message以及消息处理的回调实现,一个线程可以有多个Handler对象

Looper:消息的遍历者,从MessageQueue中循环取出Message进行处理,一个线程最多只有一个

MessageQueue:消息队列,存放了Handler发送的消息,供Looper循环取消息,一个线程最多只有一个

 2021-08-12 16:26

阅读原文

简介:一个有10多年经验开发的android、java、前端等语言的老程序员,在这里一起聊聊技术,一起聊聊生活、一起聊聊中年危机的生存之道,一起进步一起加油,感兴趣的欢迎订阅;不定时的更新。欢迎关注微信公众号:Android开发编程
(0)
打赏 喜欢就点个赞支持下吧 喜欢就点个赞支持下吧

声明:本文来自“Android开发编程”,分享链接:https://www.zyxiao.com/p/323704    侵权投诉

网站客服
网站客服
内容投稿 侵权处理
分享本页
返回顶部