图解Handler机制

1. 前言

在Android开发中,Handler机制是一个很重要的知识点,主要作用是消息通信。
下面是Handler机制的原理图,先不要急,等看完这篇文章,这个图就很简单了。


Handler机制.png

2. Handler的简单使用

我们一般使用handler发送消息,只需要两步,首先是创建一个Handler对象,并重写handleMessage方法,就是上图中的3(Message.target.handleMeesage),然后需要消息通信的地方,通过Handler的sendMessage方法发送消息(这里我们创建了一个子线程,模拟子线程向主线程发送消息)。代码如下:

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";

    private Handler mHandler;
    private Button btnSendeToMainThread;
    private static final int MSG_SUB_TO_MAIN= 100;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 1.创建Handler,并重写handleMessage方法
        mHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                // 处理消息
                switch (msg.what) {
                    case MSG_SUB_TO_MAIN:
                        // 打印出处理消息的线程名和Message.obj
                        Log.e(TAG, "接收到消息: " +    Thread.currentThread().getName() + ","+ msg.obj);
                        break;
                    default:
                        break;
                }
            }
        };

        btnSendeToMainThread = (Button) findViewById(R.id.btn_sendto_mainthread);
        btnSendeToMainThread .setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 创建一个子线程,在子线程中发送消息
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Message msg = Message.obtain();
                        msg.what = MSG_SUB_TO_MAIN;
                        msg.obj = "这是一个来自子线程的消息";
                        // 2.发送消息
                        mHandler.sendMessage(msg);
                    }
                }).start();
            }
        });
    }
}

点击了发送按钮,看log:


image.png

这样就完成子线程向主线程发送消息,辣么,如果想要主线程向子线程发送消息呢?是否也只要在子线程中创建Handler对象,然后在主线程中拿到子线程的Handler以后,调用sendMessage发送消息。在onCreate中添加如下代码:

       // 创建一个子线程,并在子线程中创建一个Handler,且重写handleMessage
        new Thread(new Runnable() {
            @Override
            public void run() {
                subHandler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        // 处理消息
                        switch (msg.what) {
                            case MSG_MAIN_TO_SUB:
                                Log.e(TAG, "接收到消息: " +  Thread.currentThread().getName() + ","+ msg.obj);
                                break;
                            default:
                                break;
                        }
                    }
                };
            }
        }).start();

        btnSendToSubThread = (Button) findViewById(R.id.btn_sendto_subthread);
        btnSendToSubThread.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Message msg = Message.obtain();
                msg.what = MSG_MAIN_TO_SUB;
                msg.obj = "这是一个来自主线程的消息";
                // 主线程中发送消息
                subHandler.sendMessage(msg);
            }
        });

我们点击按钮时,发现并没有成功,并且报出了如下的错误信息:


image.png

原因也说得很清楚了,说的是我们不能在一个没有调用Looper.prepare()的线程去创建Handler对象。那为什么主线程我们不需要去手动调用Looper.prepare()就可以直接使用Handler呢?原来是启动App时,系统帮我们创建好了,App的入口,是ActivityThread.main方法,代码如下:

   public static void main(String[] args) {
       // 不相干代码
       ......
       // 1.调用Looper.prepareMainLooper,其实也就是调用的Looper.loop,初始化Looper、MessageQueue等
       Looper.prepareMainLooper();
       // 2.创建ActivityThread的同时,初始化了成员变量Handler mH
       ActivityThread thread = new ActivityThread();
       thread.attach(false);
       // 
       if (sMainThreadHandler == null) {
           // 把创建的Handler mH赋值给sMainThreadHandler
           sMainThreadHandler = thread.getHandler();
       }

       if (false) {
           Looper.myLooper().setMessageLogging(new
                   LogPrinter(Log.DEBUG, "ActivityThread"));
       }
       // 3.调用Looper.loop()方法,开启死循环,从MessageQueue中不断取出Message来处理
       Looper.loop();

       throw new RuntimeException("Main thread loop unexpectedly exited");
   }

看样子,创建Handler还是需要调用Looper.prepare的,我们平常在主线程不需要手动调用,是因为系统在启动App时,就帮我们调用了。并且还需要调用Looper.loop方法,这个方法后面我们会讲到。所以使用Handler通信之前需要有以下三步:

  1. 调用Looper.prepare()
  2. 创建Handler对象
  3. 调用Looper.loop()

那按照这个套路,我们完善下之前的代码,其实就是在子线程中创建Handler之前调用Looper.prepare(),之后调用Looper.loop()方法,如下:

// 创建一个子线程,并在子线程中创建一个Handler,且重写handleMessage
        new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                subHandler = new Handler() {
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        // 处理消息
                        switch (msg.what) {
                            case MSG_MAIN_TO_SUB:
                                Log.e(TAG, "接收到消息: " +  Thread.currentThread().getName() + ","+ msg.obj);
                                break;
                            default:
                                break;
                        }
                    }
                };
                Looper.loop();
            }
        }).start();

这时候再点击按钮,在主线程向子线程发送消息,log如下图。


image.png

现在就可以使用Handler在主线程向子线程发送消息了,且可以看到,是在子线程中处理消息的。

3. Handler机制原理

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

  1. Message:消息
  2. Hanlder:消息的发起者
  3. Looper:消息的遍历者
  4. MessageQueue:消息队列

下面我们从Handler的套路,来一一分析他们的作用

3.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的副本。如下图:


ThreadLocal.png

接下来看Looper的构造方法:

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

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

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

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

  1. 创建Looper对象
  2. 创建MessageQueue对象,并让Looper对象持有
  3. 让Looper对象持有当前线程

3.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的创建过程就结束了,主要有以下几点

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

2.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中取出消息以后的分发,如下面的流程图所示:


Message分发.png

所以Looper.loop的作用就是:从当前线程的MessageQueue从不断取出Message,并调用其相关的回调方法。

2.4 发送消息

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


image.png
image.png

我们先来看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中去。

4. 总结

我们再来总结下Handler消息机制主要的四个类的功能

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

再来看看开始的结构图,是不是一目了然了:


Handler机制.png

6. 课后题

  1. Android中,有哪些是基于Handler来实现通信的?
  2. 处理Handler消息,是在哪个线程?一定是创建Handler的线程么?
  3. 消息是如何插入到MessageQueue中的?
  4. 当MessageQueue没有消息时,它的next方法是阻塞的,会导致App ANR么?
  5. 子线程中可以使用Toast么?
  6. Looper.loop()是死循环,可以停止么?
  7. Handler内存泄露怎么解决?

篇幅问题,放到下一篇详解,点击Handler课后题

推荐阅读更多精彩内容