Android并发编程之Handler，MessageQueue，Looper详解

Handler和Looper，MessageQueue之间是什么关系？

Looper和MessageQueue是线程中的概念，但是线程默认是没有Looper和MessageQueue的，我们需要手动去设置他们，当一个线程有了Looper和MessageQueue后，就可以关联一个Handler，我们再通过这个Handler，就可以从别的线程中发送消息给这个线程来执行。

我们给一个线程配置了Looper和MessageQueue后，当有消息通过Handler发送到本线程后，就会加入到MessageQueue中，然后Looper会不断的循环从MessageQueue中取出消息，然后放到Handler的handleMessage（）中去执行。

如何给一个线程配置一个Looper和MessageQueue

给一个线程配置一个Looper和MessageQueue很简单，只需要调用Looper.prepare()和Looper.loop()就可以了。 
首先我们先来看一下Looper.prepare()中都做了什么

/** 
     *当我们调用了prepare后，我们就给这个线程配置了一个Looper，然后调用
     *loop（）方法后会创建MessageQueue并且looper会进入无限循环来从消息
     *队列中取出消息去处理，我们调用quit（）方法可以使looper结束这个无限
     *循环
      */
    public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        //ThreadLocal是线程本地存储，每个线程的ThreadLocal中存的数据
        //都是不一样的，他们只属于本线程，当我们为该线程创建了一个Looper
        //之后，将这个Looper存储到ThreadLocal中，一个线程只能有一
        //个Looper，如果再次调用prepare方法的话，就会抛出异常
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //new出了一个Looper
        sThreadLocal.set(new Looper(quitAllowed));
    }

再来看一下Looper.loop()方法中做了什么

/**
     * 当调用了loop方法后，Looper会无限循环从MessageQueue中取出消息，
     * 因此我们一定要调用quit()来退出循环
     */
    public static void loop() {
        //获取当前线程的Looper
        final Looper me = myLooper();
        if (me == null) {
            //如果没有调用Loop.prepare()的话，就会抛出下面这个异常
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        //创建一个MessageQueue
        final MessageQueue queue = me.mQueue;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        //无限循环
        for (;;) {
            //从MessageQueue中取出消息
            Message msg = queue.next(); // might block
            if (msg == null) {
                // 没有消息，说明消息队列已经退出了，因此跳出循环
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
            //msg.target就是与此线程关联的Handler对象，
            //dispatchMessage方法将msg交给Handler去处理
            msg.target.dispatchMessage(msg);

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }
            //msg已经交给Handler去处理，这里将msg复位
            msg.recycleUnchecked();
        }
    }

我们看到从MessageQueue取出的消息会调用Handler的dispatchMessage方法去执行，我们看看dispatchMessage做了什么事情

/**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

dispatchMessage方法中会判断msg中有没有设置callback，这个callback是一个Runnable对象，如果设置了的话就会交给handleCallback方法去执行

private static void handleCallback(Message message) {
        //因为callable是一个Runnable对象，因此在这里会调用Runnable的run方法
        message.callback.run();
    }

如果msg中没有设置callback，那么就直接将消息交给handleMessage去处理，这个handleMessage我们都很熟悉，我们写Handler时候都会重写这个方法

Handler如何关联一个有Looper和MessageQueue的线程

Handler关联一个Looper其实很简单，Looper是属于一个线程的，我们只需要用Handler的一个构造方法，我们传入哪个线程的Looper，Handler就会将消息发送到哪个线程。

/**
     * Use the provided {@link Looper} instead of the default one.
     *
     * @param looper The looper, must not be null.
     */
    public Handler(Looper looper) {
        this(looper, null, false);
    }

工作线程发送消息到主线程

工作线程发消息到主线程这个大家应该是最熟悉不过的了，我们平常最常见的写法是这样的

public class MainActivity extends AppCompatActivity {
    //创建Handler，不指定Looper是默认关联当前线程即main线程的Looper
    private Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Log.i("zhangqi","消息发送到"+Thread.currentThread().getName());
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new Thread(){
            @Override
            public void run() {
                try {
                    //模拟耗时操作
                    TimeUnit.SECONDS.sleep(2);
                    //发送消息
                    Message message = mHandler.obtainMessage();
                    message.sendToTarget();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }


}

Handler导致的内存泄露

我们看到消息成功发送到了主线程中，我们通常通过这种方式在工作线程做耗时操作，然后通过Handler发送消息到主线程来更新UI，但是这样的写法会导致内存泄露。我们看一下AS给我们的提示：这个Handler应该是静态的否则会因此内存泄露 

 

我们来解释一下，因为我们的Handler的创建是一个内部类的方式，一个内部类会持有他的外部类的一个引用，因此这回影响GC来回收外部类，也就是GC无法回收当前的Activity，如果我们的Handler是关联的工作线程的Looper和MessageQueue，这样做则没有影响。如果Handler关联的是主线程的Looper和MessageQueue，则我们应该写成静态内部类的方式，如果我们的静态内部类中要用到外部类的成员变量，我们应该传入一个外部类的弱引用，弱引用会在内存不够用的情况下被GC回收，因此不会造成内存泄露的问题。同样，我们的Thread也是一个内部类，他持有外部类的一个引用，因此Thread也应该写成静态内部类的方式，那么正确的写法应该如下：

public class MainActivity extends AppCompatActivity {


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MyThread mThread = new MyThread(new MyHandler());
        mThread.start();
    }

    /**
     * 写成静态内部类的形式，不会持有外部类的引用
     */
    private static class MyThread extends Thread {
        //Thread中持有MyHandler的一个弱引用
        private WeakReference<Handler> mHandler;
        //在构造方法中将Handler传进来
        public MyThread(Handler handler) {
            mHandler = new WeakReference<Handler>(handler);
        }

        @Override
        public void run() {
            Handler handler = mHandler.get();
            if (handler!=null) {
                try {
                    TimeUnit.SECONDS.sleep(2);
                    //发送一个消息
                    Message message = handler.obtainMessage();
                    message.sendToTarget();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                //Handler被GC回收了
            }

        }
    }

    private static class MyHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Log.i("zhangqi", "消息发送到" + Thread.currentThread().getName());
        }
    }

}

主线程发送消息到工作线程

主线程发送消息到工作线程，我们要创建一个工作线程并且给他配置Looper和MessageQueue，然后创建一个Handler并且关联这个线程的Looper后，在主线程可以调用Handler的send，post等方法发送一个message或者runnable到Handler所在的线程执行了。下面这个例子是谷歌官方推荐的写法

public class MainActivity extends AppCompatActivity {
    private Worker mWorker;
    private Handler mHandler;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //当Worker创建完毕后，他是一个配置了Looper和
        //MessageQueue的线程
        mWorker = new Worker("工作线程");
        //创建一个Handler并且关联一个Looper
        mHandler = new MyHandler(mWorker.getLooper());
        //通过Message资源池中拿到一个Message
        Message message = mHandler.obtainMessage();
        //将message发送到Handler所关联的线程中去
        message.sendToTarget();
    }

    /**
     * 这个Worker的构造方法是阻塞式的，只有当调用了Looper.prepare
     * 和Looper.loop之后才会构造完成，因此只要Worker构造出来了，
     * 那他就一定已经配置好了Looper和MessageQueue
     */
    private static class Worker implements Runnable{
        //对象锁
        private Object lock = new Object();
        //当前线程的Looper对象
        private Looper mLooper;
        //构造方法
        public Worker(String name){
            //创建一个线程，线程的第二个参数是一个Runnable对象，
            //我们传入this表示这个Thread会执行此Runnable的run方法
            Thread t = new Thread(null,this,name);
            //开启线程，这样就会去执行run方法
            t.start();
            //同步代码块
            synchronized (lock){
                //mLooper实在run方法中赋值，如果mLooper还没有
                //被赋值的话，就会阻塞等待
                while (mLooper == null){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
        }
        //调用了thread.start后就会执行这个run方法
        @Override
        public void run() {
            //同步代码块，记住锁一定要和上面的锁是同一个锁
            synchronized (lock){
                //调用prepare方法，配置looper
                Looper.prepare();
                //给mLooper赋值
                mLooper = Looper.myLooper();
                //当给mLooper赋值之后，就调用notifyAll去唤醒上面
                //构造方法
                lock.notifyAll();
            }
            //配置MessageQueue并且Looper开始轮巡
            Looper.loop();
        }
        //暴露一个方法来获得当前线程的looper
        public Looper getLooper(){
            return mLooper;
        }
    }

    /**
     * 静态内部类不持有MainActivity的引用，避免内存泄露，并且重写handleMessage（）
     * Handler发送的消息最终会在handleMessage中执行
     */
    private static class MyHandler extends Handler{
        public MyHandler(){

        }
        public MyHandler(Looper looper){
            super(looper);
        }
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Log.i("zhangqi","消息发送到"+Thread.currentThread().getName());
        }
    }
}

我们在Handler的handleMessage中打印一个Log，这个Log会告诉我们这个消息发送到了哪个线程中 

 

那如果我们在创建Handler的时候不指定关联哪个Looper的话，消息会发送的主线程

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mWorker = new Worker("工作线程");
        //Handler不指定Looper的话，就会自动关联创建Handler线程
        //的Looper，这里就会关联主线程的Looper
        mHandler = new MyHandler();
        //通过obtainMessage可以从Message资源池中拿到一个message
        Message message = mHandler.obtainMessage();
        //调用sendToTarge就可以将message发送到handler关联的工作线程中了
        message.sendToTarget();
    }

一定不要忘了调用Looper.quit来结束Looper的循环

刚才前面我们说过，如果我们不调用Looper.quit的话，那么Looper就会无限循环从MessageQueue中取消息，这将导致Thread无法停止工作，无法被GC回收，如果我们的Thread中还保存了Activity的引用的话，将导致Activity也无法被GC回收，最终会导致内存泄露，我们可以在Activity的onDestroy中判断当前线程是否结束

@Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i("zhangqi", "onDestroy");
//        mWorker.getLooper().quit();
        while(mWorker.isAlive()){
            Log.i("zhangqi","线程仍在运行");
        }
        Log.i("zhangqi","线程结束运行");
    }

 

我们发现即使Acitvity的onDestroy已经执行了，但是线程仍然在工作着，所以我们需要在onDestroy中调用Looper的quit方法

@Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i("zhangqi", "onDestroy");
        mWorker.getLooper().quit();
        while(mWorker.isAlive()){
            Log.i("zhangqi","线程仍在运行");
        }
        Log.i("zhangqi","线程结束运行");
    }

我们再来看一下 

 

最后这个线程结束了运行，因此我们千万不要忘记调用Looper的quit方法来结束他的循环，否则将导致线程永远执行下去

工作线程发送消息到工作线程

public class MainActivity extends AppCompatActivity {
    private Worker mWorker;
    private Handler mHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mWorker = new Worker("工作线程B");
        new Thread("工作线程A") {
            @Override
            public void run() {
                //在工作线程A中创建Handler并且关联工作线程B的Looper
                mHandler = new MyHandler(mWorker.getLooper());
                Message message = mHandler.obtainMessage();
                //发送消息
                message.sendToTarget();
            }
        }.start();
    }

    /**
     * 这个Worker的构造方法是阻塞式的，只有当调用了Looper.prepare
     * 和Looper.loop之后才会构造完成，因此只要Worker构造出来了，
     * 那他就一定已经配置好了Looper和MessageQueue
     */
    private static class Worker implements Runnable {
        private Thread t;
        //对象锁
        private Object lock = new Object();
        //当前线程的Looper对象
        private Looper mLooper;

        //构造方法
        public Worker(String name) {
            //创建一个线程，线程的第二个参数是一个Runnable对象，
            //我们传入this表示这个Thread会执行此Runnable的run方法
            t = new Thread(null, this, name);
            //开启线程，这样就会去执行run方法
            t.start();
            //同步代码块
            synchronized (lock) {
                //mLooper实在run方法中赋值，如果mLooper还没有
                //被赋值的话，就会阻塞等待
                while (mLooper == null) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
        }

        //调用了thread.start后就会执行这个run方法
        @Override
        public void run() {
            //同步代码块，记住锁一定要和上面的锁是同一个锁
            synchronized (lock) {
                //调用prepare方法，配置looper
                Looper.prepare();
                //给mLooper赋值
                mLooper = Looper.myLooper();
                //当给mLooper赋值之后，就调用notifyAll去唤醒上面
                //构造方法
                lock.notifyAll();
            }
            //配置MessageQueue并且Looper开始轮巡
            Looper.loop();
        }

        //暴露一个方法来获得当前线程的looper
        public Looper getLooper() {
            return mLooper;
        }
         public boolean isAlive(){
            return t.isAlive();
        }
    }

    /**
     * 静态内部类不持有MainActivity的引用，避免内存泄露，并且重写handleMessage（）
     * Handler发送的消息最终会在handleMessage中执行
     */
    private static class MyHandler extends Handler {
        public MyHandler() {

        }

        public MyHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Log.i("zhangqi", "消息发送到" + Thread.currentThread().getName());
        }
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i("zhangqi", "onDestroy");
        mWorker.getLooper().quit();
        while(mWorker.isAlive()){
            Log.i("zhangqi","线程仍在运行");
        }
        Log.i("zhangqi","线程结束运行");
    }
}

 

我们在工作线程A中创建了一个Handler并且关联了工作线程B的Looper，在工作线程A中发送一个消息，最终消息发送到了工作线程B中。 为了验证创建Handler的时候，不手动关联Looper的话是默认关联创建Handler所在线程的Looper，我们在工作线程中创建Handler的时候不手动指定Looper，我们看看会出什么问题 

 

抛出了运行时异常：不能在没有调用Looper.prepare的线程中创建Handler，那我们给工作线程A加上Looper.prepare和Looper.loop

new Thread("工作线程A") {
            @Override
            public void run() {
                Looper.prepare();
                //在工作线程A中创建Handler并且不指定Looper
                mHandler = new MyHandler();
                Message message = mHandler.obtainMessage();
                //发送消息
                message.sendToTarget();
                Looper.loop();
            }
        }.start();

 

好了，这就证实了如果我们创建Handler的时候不手动指定他要关联哪一个Looper的话，就会默认关联创建Handler的线程的Looper，但是当前线程一定要配置Looper和MessageQueue，否则会报错。 

那为什么刚才在主线程中直接创建Handler没有报错呢？那是因为主线程中已经默认配置了Looper和MessageQueue，因此我们可以直接创建Handler。

结束语

关于Handler,MessageQueue和Looper已经说完了，这是我自己通过写Demo和看资料总结出来的，如果有哪些地方不对希望大家可以帮我指正。或者有哪些没说到的也希望大家帮我补充。