Handler你真的搞懂了吗？

目录

一、Handler、Looper、MessageQueue、Message的关系

1.1、消息机制流程

1.2、Looper创建

二、消息入队解析

2.1、sendMessage

2.2、enqueueMessage

2.3、postSyncBarrier同步屏障消息

三、消息分发解析

3.1、Looper.loop()

3.2、Handler.dispatchMessage

3.3、ThreadLocal（扩展内容了解即可）

四、Handler高频面试考点

---

先说两句废话，之前的这很长一段时间，由于各种原因吧，真的是很久没写过文章了，人性中的惰性真的太可怕了，我们都应该努力克服惰性，好在今天，我又回来了，重拾学习总结，养成一个良好的学习习惯，歪瑞雇的！

今天我们来复习总结一下Handler的相关知识点，把一些常见的问题整理出来，下次需要的时候可以再翻出来看一看，文中资料是参考的慕课网的《移动端架构师》课程中的Handler部分的讲解。

一、Handler、Looper、MessageQueue、Message的关系

1.1、消息机制流程

首先来看下面这张图：一个线程至多一个Looper；一个Looper有一个MessageQueue；一个MessageQueue对应多个message；一个MessageQueue对应多个Handler。通过这张图我们来把整个Android消息机制的流程串联起来理解一下：

Android的消息机制基本上是由Handler、Looper、MessageQueue、Message这几个类来支撑的，实际上整个Android系统也是一个消息驱动的系统，如果没有这几个类，Android中的各种事件、各种消息都无法得到执行，所以搞懂消息机制就显得至关重要了。

Handler：负责发送消息以及处理消息，无论我们使用哪种发送消息的方式，最终都是通过enqueueMessage将消息加入到MessageQueue这个消息队列中去。

MessageQueue：由于我们发送的消息并不是立刻就会得到执行的，所以消息需要一个能够存储它的地方，因此就有了MessageQueue这个消息队列。它的内部是由一个单向链表来实现的，同一时刻只会有一条消息被触发，因此队列内的消息会以自身被触发的时间顺序排列在队列之中，无论何时，队列头部的这条消息它的被触发时间都是最接近的。

队列之中一共有三种类型的消息：BarrierMessage：同步屏障消息；AsyncMessage：异步消息；Message：同步消息。

那么队列中的消息如何才能让它们在必要的时间得到执行呢？此时就需要依靠Looper这个无限循环的消息驱动器了。

Looper：无限循环的消息驱动器，它负责关联线程以及消息的分发，Looper创建的时候会创建一个MessageQueue，Looper会通过loop()方法开启一个无限循环，它会从头开始遍历队列，不断调用MessageQueue的next()方法检查是否有满足条件的消息，有则取出这条消息将其分发并执行，没有则阻塞在next()方法中。当Looper的quit()方法被调用时会调用MessageQueue的quit()，此时next()会返回null，之后loop()方法也会跟着退出。

Message：消息，每条消息内部都有以下几个重要的属性：

when：这条消息被执行的时间戳，这也是它在整个队列中排序的唯一的依据；

next：由于消息队列是一个单向链表，所以每条消息内部都会包含下一条消息的引用关系；

target：代表每条消息是由哪个Handler对象发送的，之后也会由这个Handler对象来消费。

整个消息循环的流程总结如下：

Handler通过sendMessage()方法发送消息Message到消息队列MessageQueue中，Looper通过loop()方法不断获取触发条件的Message，然后将Message交给对应的Handler，最后Handler调用自身的handleMessage()方法处理Message。

1.2、Looper创建

我们平时在主线程中使用Handler时，并没有写关于Looper的相关代码，为什么也能发送消息呢？

• 在ActivityThread.main()方法中调用了Looper.prepareMainLooper()方法创建了主线程的Looper，然后调用了loop()开启了消息循环
• 通常我们说ActivityThread就是主线程，但是实际上它并不是一个线程，而是主线程操作的管理者

class Handler{
    public Handler() {this(null, false);}
    public Handler(boolean async) {this(null, async);}
    public Handler(Callback callback, boolean async) {
        // 如果没调用Looper.prepare则为空
        // 主线程创建Handler不用创建Looper，就是因为ActivityThread在进程入口调用了Looper.prepareMainLooper()帮我们创建好了
        mLooper = Looper.myLooper();
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
}

Looper.myLooper()是如何保证获取到的就是本线程的looper对象的呢？

class Looper{
    // sThreadLocal是static变量，可以简单理解它相当于Map，key是线程，value是Looper
    // 那么就可以用当前线程的sThreadLocal获取当前线程所属的Looper
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    // Looper所属的线程的消息队列
    final MessageQueue mQueue;
    
    private static void prepare(boolean quitAllowed) {
        // 一个线程只能有一个Looper，prepare不能重复调用
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }
    
    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
    }
    
    public static @Nullable Looper myLooper() {
        // 具体看ThreadLocal类源码的get方法
        // 简单理解相当于map.get(Thread.currentThread())获取当前线程的Looper
        return sThreadLocal.get();
    }
}

二、消息入队解析

2.1、sendMessage

根据我们平时的使用经验，可以知道我们在发送一条消息的时候，一般有两种方式：postXXX和sendXXX，无论我们使用的是哪种方式，最后都会以Message的形式插入到消息队列中，比如你使用post发送消息时，都会通过getPostMessage()将Runnable对象包装成Message对象，然后再次调用send方法把它加入到队列中：

class Handler{
    public final boolean post(Runnable r){
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
    // 将Runnable包装成Message
    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }
}

class Message{
    public static final Object sPoolSync = new Object();
    private static Message sPool;
    private static int sPoolSize = 0;
    private static final int MAX_POOL_SIZE = 50;

    // 消息复用
    public static Message obtain() {
        // 单向链表形式的对象池
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

    // 消息回收
    void recycleUnchecked() {
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
}

这里在获取消息的时候是使用的Message.obtain()方法，这是Message为我们提供的消息复用池的能力，它内部最多会缓存50个Message对象，使用这种方式可以直接从复用池中取消息，不用new对象，不会产生大量的临时变量，因此不会造成CPU内存占用率过高的问题。消息池既然提供了对象共享的能力，那么肯定也会提供对象回收的能力，当每一条消息被执行完成之后，都会走到recycleUnchecked()方法中，从而将Message对象重置，数据被清空，然后再将它插入到链表的头结点，进而形成了一个队头复用的消息池。

2.2、enqueueMessage

MessageQueue是一个单项链表，所以它的每个节点都包含一个next对象用来指向下一个节点：

无论使用哪种发送消息的方式，最终都会走到enqueueMessage方法里面：

• 如果新消息的被触发时间when比队列中的任何一个消息都早，那么则插入队头，唤醒Looper
• 如果当前队列头部是同步屏障消息，新消息是异步消息，那么也要唤醒Looper

下面来看这一部分的代码，通过注释来做说明：

class Handler{
    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        // 把msg的target赋值成当前的Handler
        msg.target = this;
        ...
        return queue.enqueueMessage(msg, uptimeMillis);
    }
}

class MessageQueue{
    boolean enqueueMessage(Message msg, long when) {
        // 普通消息的target字段不能为空，否则不知道该交由谁来处理这条消息
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }

        synchronized (this) {
            msg.when = when;
            // mMessage始终是队头消息
            Message p = mMessages;
            boolean needWake;
            // 如果队头消息为空，或消息的when=0不需要延迟，或newMsg.when<headMsg.when，则插入队头
            if (p == null || when == 0 || when < p.when) {
                // 插入队头，把newMsg.next指向原队头节点p，newMsg赋值给mMessage，newMsg则成了队头
                msg.next = p;
                mMessages = msg;
                // 如果当前Looper处于休眠状态，则本次插入消息之后需要唤醒
                needWake = mBlocked;
            } else {
                // 要不要唤醒Looper=当前处于休眠状态&队头消息是同步屏障消息&新消息是异步消息
                // 目的是为了让异步消息尽早执行
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    // 按时间顺序找到该消息合适的位置
                    // msg.when=2-->msg.when=4-->msg.when=6
                    // msg.when=2-->msg.when=4-->【newMsg.when=5】-->msg.when=6
                    // prev对象就是队列中最后一个时间戳小于新消息时间戳的message对象
                    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;
            }

            // 唤醒Looper，走的是native方法
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }
}

2.3、postSyncBarrier同步屏障消息

• message.target=null，这类消息不会被真的执行，它起到flag标记的作用，MessageQueue在遍历消息队列的时候，如果队头是同步屏障消息，那么会忽略同步消息，优先让异步消息得到执行。这就是它的目的，一般情况下异步消息和同步屏障消息会一起使用。
• 异步消息&同步屏障使用场景

1. ViewRootImpl接收屏幕垂直同步信号事件用于驱动UI测绘
2. ActivityThread接收AMS的事件驱动生命周期
3. InputMethodManager分发软键盘输入事件
4. PhoneWindowManager分发电话页面各种事件

class MessageQueue{
    public int postSyncBarrier() {
        // currentTimeMillis()系统当前时间，即日期时间，可以被系统设置修改，如果设置系统时间，时间值会发生跳变
        // uptimeMillis()自开机后经过的时间，不包括深度休眠时间
        // sendMessageDelay,postDelay也都使用了这个时间戳
        // 意思是指发送了这条消息，在此期间如果设备进入休眠状态，那么消息是不会被执行的，设备唤醒之后才会被执行
        return postSyncBarrier(SystemClock.uptimeMillis());
    }

    private int postSyncBarrier(long when) {
        synchronized (this) {
            // 从消息池复用，构建新消息体
            final Message msg = Message.obtain();
            // 并没有给target字段赋值，区分是否是同步屏障，就看target是否等于null
            msg.when = when;

            Message prev = null;
            Message p = mMessages;
            // 遍历队列所有消息，直至找到一个message.when>msg.when的消息，决定新消息插入的位置
            if (when != 0) {
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
            }
            // 如果找到了合适的位置则插入
            if (prev != null) { // invariant: p == prev.next
                msg.next = p;
                prev.next = msg;
            } else {
                // 如果没有找到，则直接放在队头
                msg.next = p;
                mMessages = msg;
            }
            return token;
        }
    }
}

 注意：屏障消息在插入队列时，并没有去主动唤醒线程，因为屏障消息不需要被执行。那么屏障消息是在什么时候从队列中被移除呢？答案是：谁添加的就由谁来移除，比如ViewRootImpl在接收垂直同步信号的时候会发送一条异步消息和一条同步屏障消息，当异步消息得到执行的时候，ViewRootImpl就会把同步屏障从队列中移除。

三、消息分发解析

3.1、Looper.loop()

队列中的消息之所以能够得到分发，根据流程图中的分析，它是靠Looper类调用loop()方法开启一个无限for循环的消息驱动器，如下代码所示：

class Looper{
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;
        ......
        for (;;) {
            // 无限循环，调用MessageQueue的next获取可执行的消息，注意官方注释，这里可能会阻塞
            Message msg = queue.next(); // might block
            if (msg == null) {
                return;
            }
            ......
            // 分发消息
            msg.target.dispatchMessage(msg);
            ......
            // 回收message对象，留着复用
            msg.recycleUnchecked();
        }
    }
}

在loop()方法的内部，会调用MessageQueue的next()方法获取一条可执行的消息对象。

注意：在Message msg = queue.next()；这行代码的后面官方给了一个注释：might block，它的意思是，该next()方法可能会使得当前线程进入阻塞状态，此时该方法将不会有返回值，后续的代码也不会得到执行，所以这里的无限for循环并不会一直这样空轮询下去，它的目的只是为了不让这个线程退出。

那么接下来我们就来看一下MessageQueue的next()方法：

class MessageQueue{
    Message next() {
        int nextPollTimeoutMillis = 0;
        for (;;) {
            // 如果nextPollTimeoutMillis>0，则Looper会进入休眠状态，第一次值等于0，所以不会
            // 如果第一次循环未找到需要处理的消息，则nextPollTimeoutMillis会被更新
            // 在第二次循环时，如果nextPollTimeoutMillis!=0，Looper线程会进入阻塞状态
            // 在此期间主线程没有实际工作要做，会释放CPU资源，该方法超时会自主恢复，或者插入新消息时被动恢复
            nativePollOnce(ptr, nextPollTimeoutMillis);

            // 当Looper被唤醒时，会继续向下执行
            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                // 如果队头是屏障消息，则尝试找到一个异步消息
                if (msg != null && msg.target == null) {
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // 如果上面找到的消息的时间还没到需要执行的时间
                        // 则更新nextPollTimeoutMillis，即：下一次循环需要阻塞的时间值
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // 找到了需要处理的消息
                        mBlocked = false;
                        // 由于这个消息即将被处理，所以需要把它从队列中移除
                        // 通过调整节点的指向关系，达到队列元素移除的目的
                        if (prevMsg != null) {
                            // 要删除的消息位于队列的中间位置
                            prevMsg.next = msg.next;
                        } else {
                            // 要删除的消息位于队头的位置
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // 如果没有消息，即队列为空，Looper将进入无限阻塞状态，直到有新消息到达
                    nextPollTimeoutMillis = -1;
                }

                // 当队列消息为空，也就是所有任务都处理完了，或者队头消息已经达到了可执行时间点
                // 此时派发通知 Looper即将进入空闲状态
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                if (pendingIdleHandlerCount <= 0)return
            }
            // 注册MessageQueue.IdleHandler，可以监听当前线程的Looper是否处于空闲状态，也就意味着线程是否处于空闲状态
            // 在主线程中可以监听这个事件来做延迟初始化，数据加载，日志上报等优化操作
            // 并不是有任务就提交，避免抢占重要资源
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                boolean keep = false;
                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }
            // 此时置为0，既然监听了线程的空闲，那么在queueIdle回调里，可能又会产生新的消息
            // 为了让消息尽可能早的得到执行，所以此时不需要再休眠了
            nextPollTimeoutMillis = 0;
        }
    }
}

3.2、Handler.dispatchMessage

这里我们需要掌握的就是消息分发的优先级：

1. Message的回调方法：message.callback.run()，优先级最高
2. Handler的回调方法：Handler.mCallback.handleMessage(msg)
3. Handler的默认方法：Handler.handleMessage(msg) 

class Handler{
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
}

对于这三种方式的使用，我们简单举例说明如下：

        // 1.直接在Runnable中处理任务
        Handler handler1 = new Handler();
        // 这条消息在消费时是回调给Message的Callback，这个callback就是这里传递的Runnable对象
        handler1.post(new Runnable() {
            @Override
            public void run() {

            }
        });
        // 2.使用Handler.Callback来接收处理消息
        Handler handler2 = new Handler(new Handler.Callback() {
            @Override
            public boolean handleMessage(@NonNull Message message) {
                return true;
            }
        });
        // 3.使用handleMessage来接收处理消息
        Handler handler = new Handler(){
            @Override
            public void handleMessage(@NonNull Message msg) {
                super.handleMessage(msg);
            }
        };

3.3、ThreadLocal（扩展内容了解即可）

ThreadLocal提供了线程独有的局部变量存储能力，可以在整个线程存活的过程中随时取用。

Thread--->ThreadLocalMap--->Entry--->key:ThreadLocal & value:T

ThreadLocalMap的数据模型：

• 每个线程对应一个ThreadLocalMap对象，本质是一个数组实现的散列map
• 每个元素都是Entry对象，key=threadLocal，value为任意值

class ThreadLocal{
    public void set(T value) {
        // 获取当前线程的ThreadLocalMap对象
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value); // 更新值，key=threadLocal
        else
            createMap(t, value); // 创建并设置值
    }

    void createMap(Thread t, T firstValue) {
        // 每个线程都有一个ThreadLocalMap，key为threadLocal对象
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    public T get() {
        // 获取当前线程对象，通过线程获取ThreadLocalMap对象
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        // 不为空则取值
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

    private T setInitialValue() {
        // 得到被调用的threadLocal的初始值
        T value = initialValue();
        // 得到当前线程
        Thread t = Thread.currentThread();
        // 获取或者创建每个线程的ThreadLocalMap，并把初始值存放进去
        // 从而实现变量拷贝，变成线程独享
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

    static class ThreadLocalMap{
        // 本质是一个数组
        private Entry[] table;
        // 继承自WeakReference
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            Entry(ThreadLocal<?> k, Object v) {
                // key被若引用持有，当若引用所持有的对象的强引用被置为空，在GC扫描到时会被回收
                // 线程池中使用时需注意任务执行完成后，需手动把Value移除掉，否则易造成内存泄漏
                super(k);
                // value 强引用赋值
                value = v;
            }
        }
    }
}

四、Handler高频面试考点

1、为什么主线程不会因为Looper.loop()里的死循环卡死？

主线程确实是通过Looper.loop()进入了循环状态，因为这样主线程才不会像平时创建的一般的线程一样，当可执行代码执行完后，线程生命周期就终止了。

在主线程的MessageQueue没有消息时，便阻塞在MessageQueue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到有新消息到达，所以主线程在大多数时候都是处于休眠状态，并不会消耗大量CPU资源。

这里采用的Linux的epoll机制，是一种IO多路复用机制，可以同时监控多个文件描述符，当某个文件描述符就绪（读或写就绪），则立刻通知相应程序进行读或写操作拿到最新的消息，进而唤醒等待的线程。

2、post和sendMessage这两种发送消息的方式有什么区别？

post一类的方法发送的是Runnable对象，但是在最后还是会被封装成Message对象，将Runnable对象赋值给Message对象中的callback变量，然后交由sendMessageAtTime()方法发送出去。在处理消息时，会在dispatchMessage()方法里首先被handleCallback(msg)方法执行，实际上就是执行Message对象里面的Runnable对象的run()方法。

sendMessage一类的方法发送的直接是Message对象，处理消息时，在dispatchMessage里优先级会低于handleCallback(msg)方法，是通过自己重写的handleMessage(msg)方法执行。

3、为什么要通过Message.obtain()方法获取Message对象？

Message.obtain()方法可以从全局消息池中得到一个空的Message对象，这样可以有效节省系统资源。同时，通过各种obtain重载方法还可以得到一些Message的拷贝，或对Message对象进行一些初始化。

4、Handler实现发送延迟消息的原理是什么？

我们平时用postDelayed()与sendMessageDelayed()来发送延迟消息，其实最终都是将延迟时间转为确定时间，然后通过sendMessageAtTime()--->enqueueMessage--->queue.enqueueMessage这一系列方法将消息插入到MessageQueue中。所以并不是先延迟再发送消息，而是直接发送消息，再借助MessageQueue的设计来实现消息的延迟处理。

消息延迟处理的原理涉及MessageQueue的两个静态方法MessageQueue.next()和MessageQueue.enqueueMessage()。通过Native方法阻塞线程一定时间，等到消息的执行时间到了之后再取出消息执行。

5、同步屏障SyncBarrier是什么？有什么作用？

在一般情况下，同步和异步消息处理起来没有什么不同，只有在设置了同步屏障后才会有差异。同步屏障从代码层面上看是一个Message对象，但是其target属性为null，用以区分普通消息。在MessageQueue.next()方法中如果当前消息是一个同步屏障，则跳过后面所有的同步消息，找到第一个异步消息来处理。

6、IdleHandler是什么？有什么作用？

当消息队列没有消息时调用或者如果队列中仍有待处理的消息，但都未到执行时间时，也会调用此方法，用来监听主线程的空闲状态。

7、为什么非静态的Handler会导致内存泄漏？如何解决？

非静态的内部类、匿名内部类、局部内部类都会隐式的持有其外部类的引用，举个栗子：在Activity中创建的Handler会隐式的持有Activity的引用。

当我们在主线程使用Handler的时候，Handler会默认绑定这个线程的Looper对象，并关联其MessageQueue，Handler发出的所有消息都会加入到这个MessageQueue中。Looper对象的生命周期贯穿整个主线程的生命周期，所以当Looper对象中的MessageQueue里面还有未处理完的Message时，因为每个Message都持有Handler的引用，所以Handler无法被回收，那么它持有引用的外部类Activity也就无法被回收，造成内存泄漏。

解决方案：使用静态内部类+弱引用的方式

class MainActivity{
       private static class MyHandler extends Handler {
        //弱引用，在垃圾回收时，activity可被回收
        private WeakReference<MainActivity> mWeakReference;

        public MyHandler(MainActivity activity) {
            this.mWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //清空handler管道和队列
        mHandler.removeCallbacksAndMessages(null);
    }
}

8、如何在子线程中弹出Toast？

调用Looper.prepare()以及Looper.loop()，但是切记在线程任务执行完时，需要手动调用Looper.quitSafely()，否则线程不会结束。

OK，到这里今天的内容就差不多要结束了，谢谢大家，下期再会！