Android中的消息机制

44034827.png

最近需求用到Handler做了简单总结

一 概念

Handler：

将一个任务切换到Handler所在的线程中。
为什么要这个功能：
Android规定访问UI只能在主线程中进行，在子线程中坊问ui会抛出异常
在主线程中不能进行耗时超作，避免ANR异常

MessageQueue(消息对列)：

内部存储了一组信息，以对列的形式对外提供插入和删除的工作，内部的存储结构并不是真正的对列，而是采用单列表的数据结构来存储消息列表。

Looper(消息循环):

会以无限循环的形式去查找否有新消息，如果有的话就处理消息，否则就一直等待着。

ThreadLocal:

不是线程，作用是可以在每个线程中存储数据，通过ThreadLocal可以轻松获去每个线程的Looper

ActivityThread:

线程默认没有Looper,如果需要使用Handler就必须为线程创建Looper,我们的主线程就是ActivityThread,ActivityThread创建时就会初始化Looper,所以在主线程中默认可以使用Handler
Handler创建时会采用Looper来构建内部的消息循环系统，如果当前线程没有Looper,就会报错。
解决办法：
为当前线程创建Looper

二 使用

使用流程：
第一步创建Handler
这个时候其内部的Looper以及MessageQueue就可以和Handler一起工作了
第二步 两种使用方法

方法一：

通过Handler的post方法将一个Runnable投递到Handler内部的Looper中去处理

public class MainAty extends AppCompatActivity {

    private TextView tvMain;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.aty_main);
        tvMain=findViewById(R.id.tv_main);

        final Handler handler=new Handler();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.e("===========","耗时操作");
                try {
                    Thread.sleep(5000);
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            Log.e("===========","更新ui");
                        tvMain.setText("更新ui");
                        }
                    });
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();
    }

}

方法二：

通过Handler的send方法发送一个消息，这个消息同样会在Looper中处理

ackage com.myanimation.chen.mydemo;

import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

public class MainAty extends AppCompatActivity {

    private TextView tvMain;

    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            switch (msg.what) {
                case 1:
//                    tvMain.setText("111111111");
                    Log.e("============1","111111111");
                    break;
                case 2:
//                    tvMain.setText("2222222222");
                    Log.e("============2","2222222222");
                    break;

                default:

                    break;

            }
            Log.e("============3","0000000001:"+msg.what);
            Log.e("============4","0000000002:"+msg.obj);

        }
    };
    private Runnable runnable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.aty_main);
        tvMain = findViewById(R.id.tv_main);
        runnable=new Runnable() {
            @Override
            public void run() {
                Message msg;
                try {

                    for (int i = 0; i < 10; i++) {
                        msg = Message.obtain();
                        Thread.sleep(1000);
                        msg.what = i;
                        msg.obj = i;
                        handler.sendMessage(msg);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread=new Thread(runnable);
        thread.start();


        /**
         * 延迟1秒执行
         */
        handler.sendEmptyMessageDelayed(1,1000);


        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                tvMain.setText("处理好了");
            }
        },2000);


    }

补充：

(1) post也是在send方法中处理的
(2) send方法的工作过程：
第一部:Handler的send方法被调用
第二步：调用MessageQueue的enqueueMessage方法将这个消息放进消息队列中
第三步： Looper发现有新的消息就会处理这个消息
第四步： Runnable或者HandlerMessage方法就会被调用
注意：因为Looper运行在创建Handler所在的线程中，因此Handler所在的业务切换到创建Handler线程执行了。
（3）延迟2秒

        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                tvMain.setText("处理好了");
            }
        },2000);

三 问题
当Activity被Finish时引发的问题？
问题一：当Activity被finish是，Handler并未执行完，从而引起内存泄露

    static Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            switch (msg.what) {
                case 1:
                    tvMain.setText("111111111");
                    Log.e("============1","111111111");
                    break;
                case 2:
                    tvMain.setText("2222222222");
                    Log.e("============2","2222222222");
                    break;

                default:

                    break;

            }
            Log.e("============3","0000000001:"+msg.what);
            Log.e("============4","0000000002:"+msg.obj);

        }
    };

解决方法1：调用handler的地方用静态内部类
解决方法2：移除消息

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //移除指定what消息
        handler.removeMessages(1);
        //移除指定Runnable消息
        handler.removeCallbacks(runnable);
        //移除所有回调或消息
        handler.removeCallbacksAndMessages(null);
    }

解决方法4:
弱引用（WeakReference）
问题一：当Activity被finish是，执行到handlerMessage方法但相关资源已经释放，从而引起空指针
解决方法：方法中加入try/catch

四 全部代码

package com.myanimation.chen.mydemo;

import android.annotation.SuppressLint;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

import java.lang.ref.WeakReference;

public class MainAty extends AppCompatActivity {

    private TextView tvMain;
    private MainHandler handler = new MainHandler(this);

    @SuppressLint("HandlerLeak")
    class MainHandler extends Handler {

        //弱引用
        WeakReference mActivityReference;

        MainHandler(MainAty activity) {
            mActivityReference = new WeakReference<>(activity);
        }


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

            switch (msg.what) {
                case 1:
                    try {
                        tvMain.setText("111111111");
                        Log.e("============1", "111111111");
                    } catch (Exception e) {

                    }

                    break;
                case 2:
                    try {
                        tvMain.setText("2222222222");
                        Log.e("============2", "2222222222");
                    } catch (Exception e) {

                    }
                    break;

                default:

                    break;

            }
            Log.e("============3", "0000000001:" + msg.what);
            Log.e("============4", "0000000002:" + msg.obj);

        }
    }

    private Runnable runnable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.aty_main);
        tvMain = findViewById(R.id.tv_main);

        runnable = new Runnable() {
            @Override
            public void run() {
                Message msg;
                try {

                    for (int i = 0; i < 10; i++) {
                        msg = Message.obtain();
                        Thread.sleep(1000);
                        msg.what = i;
                        msg.obj = i;
                        handler.sendMessage(msg);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();


        /**
         * 延迟1秒执行
         */
        handler.sendEmptyMessageDelayed(1, 1000);


        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                tvMain.setText("处理好了");
            }
        }, 2000);


    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        //移除指定what消息
        handler.removeMessages(1);
        //移除指定Runnable消息
        handler.removeCallbacks(runnable);
        //移除所有回调或消息
        handler.removeCallbacksAndMessages(null);
    }
}