Android《多线程-中》

上篇中我们讲解了线程，进程以及Thread和Runnable之间的区别，那么这一篇我们来讲解下Android应用的消息处理机制，之后才能够更深刻的了解为什么多线程能够解决UI县城阻塞的问题。

Android 的消息处理机制

说到Android消息处理机制有的人或许有些概念模糊，那么Handler、Looper、MessageQueue，大家应该比较面熟吧。

• UI线程
  我们知道在Android应用启动时，会默认启动一个（主）UI线程，这个线程会关联一个消息队列所有的操作都会被封装成消息交给主线程来处理。为了保证主线程不会主动退出，就要将抓取消息的操作放在一个死循环中，这样我们的程序就不会主动退出并保持运行状态。
  那么和Handler 、 Looper 、Message有啥关系？其实Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息，而消息的创建者就是一个或多个Handler 。

上面虽然是原理但是并不是多好理解，我们呢打个比方：
男主：BOY
女主：Girl
当Boy和Girl 结婚后（APP启动了），那么Boy就要开始干活了（APP开启UI线程），这时候Boy就要进入疯狂工作模式了 （无限循环-Looper），而我们的Girl(Handler的一个实例)会把各种类型的账单记下来（将Message写入MessageQueue），但凡Boy接收到（Looper获取）账单（Message）就进行处理，如果是月初Girl没有给你霍霍，那么Boy就会自己攒钱了（阻塞Looper）等到月底账单来临再去处理。

举例讲完后我们来看看Handler、Looper、MessageQueue的概念。

• Handler：
  简单说Handler用于同一个进程的线程间通信，另外一个作用，就是能统一处理消息的回调。这样一个Handler发出消息又确保消息处理也是自己来做，这样的设计非常的赞。
• Looper：
  无限循环不退出的线程，Looper的另外一部分工作就是在循环代码中会不断从消息队列挨个拿出消息给主线程处理。
• MessageQueue
  MessageQueue 存在的原因很简单，就是同一线程在同一时间只能处理一个消息，同一线程代码执行是不具有并发性，所以需要队列来保存消息和安排每个消息的处理顺序。

这里就不带大家去看源代码了。
下面我峨嵋你通过一个例子来看下消息处理机制是怎么解决网络加载时阻塞UI线程问题的。

案例中我们让下载类 sleep 7秒，并且下载前和下载后都要对UI中的Text进行修改。

MainActivity.class

/**
 * Created by 泅渡者
 * Created on 2017/10/27.
 */

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

    private final Handler mHandler = new MyHandler(this);

    public static TextView tv_download;
    private Message message;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        tv_download = findViewById(R.id.tv_download);

        tv_download.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Download download = new Download();
                Thread thread = new Thread(download,"下载");
                thread.start();
            }
        });
    }


    private static class MyHandler extends Handler {

        private final WeakReference mActivity;

        public MyHandler(Activity activity) {
            mActivity = new WeakReference(activity);


        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case 1:
                    if (mActivity.get() == null) {
                        return;
                    }
                    tv_download.setText("下载中。。。");
                    break;
                case 2:
                    if (mActivity.get() == null) {
                        return;
                    }
                    tv_download.setText("下载完成");
                    break;
                    default:
                        return;
            }

        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        mHandler.removeCallbacksAndMessages(null);

    }

    class Download implements Runnable{

        @Override
        public void run() {

            try {
                message= mHandler.obtainMessage();
                message.what = 1;
                mHandler.sendMessage(message);

                Thread.sleep(7000);

                message= mHandler.obtainMessage();
                message.what = 2;
                mHandler.sendMessage(message);

            } catch (InterruptedException e) {

                Log.e(TAG,e.toString());

            }
        }
    }
}

布局文件

运行效果如下：

2.gif

我们看下面代码:

                message= mHandler.obtainMessage();
                message.what = 1;
                mHandler.sendMessage(message);

                Thread.sleep(7000);

                message= mHandler.obtainMessage();
                message.what = 2;
                mHandler.sendMessage(message);

这里我们在子线程不能操作UI线程，这个大家都知道，我们说一下obtainMessage()。

1. obtainmessage（）是从消息池中拿来一个msg 不需要另开辟空间。
2. new Message()需要重新申请，效率低。
3. obtianmessage可以循环利用。

这里还有一个比较重要的话题，就是由Handler导致Activity 的内存泄露。

Handler内存泄漏解决办法

Handler也是造成内存泄露的一个重要的源头，主要Handler属于TLS(Thread Local Storage)变量,生命周期和Activity是不一致的，Handler引用Activity会存在内存泄露。
我们一般用法是否是这样的呢？

  private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case 1:
                    //TODO
                    break;
                default:
                    return;
            }

        }
    };
------------------------------------------------------------------------------
        Message message = mHandler.obtainMessage();
        message.what = 1;
        mHandler.sendMessageDelayed(message,6000);

但是程序会提示

This Handler class should be static or leaks might occur (anonymous android.os.Handler)
意思：此处理程序类应该是静态的或可能发生泄漏 (匿名 android.os.Handler）

是什么导致的呢 ？

• 生命周期
  Handler 的生命周期与Activity 不一致，当Android应用启动的时候，会先创建一个UI主线程的Looper对象，Looper实现了一个简单的消息队列，一个一个的处理里面的Message对象。主线程Looper对象在整个应用生命周期中存在，当在主线程中初始化Handler时，该Handler和Looper的消息队列关联（没有关联会报错的）。发送到消息队列的Message会引用发送该消息的Handler对象，这样系统可以调用 Handler#handleMessage(Message) 来分发处理该消息。

• handler 引用 Activity 阻止了GC对Acivity的回收
  在Java中，非静态(匿名)内部类会默认隐性引用外部类对象。而静态内部类不会引用外部类对象。如果外部类是Activity，则会引起Activity泄露 ，当Activity finish后，延时消息会继续存在主线程消息队列中1分钟，然后处理消息。而该消息引用了Activity的Handler对象，然后这个Handler又引用了这个Activity。这些引用对象会保持到该消息被处理完，这样就导致该Activity对象无法被回收，从而导致了上面说的 Activity泄露。

• 如何避免？
  使用显形的引用：1.静态内部类 2. 外部类
  使用弱引用 ： WeakReference
  还要在程序销毁时进行remove();

@Override  
public void onDestroy() {  
    mHandler.removeCallbacksAndMessages(null);  
}  

上述案例就是应用弱引用，可能大家觉得写的代码比较多，不怕我们有办法。我们按照图的指示来创建自己的Live Templates:

2.gif

OK 今天的就到这里。