Android 中handler消息机制的理解

博主前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住也分享一下给大家，
👉点击跳转到网站

前言：

Android中在子线程中更改主线程中的组件是不允许的。
具体规则就是：子线程不允许操作主线程中的组件。

如果我们必须在子线程中更改主线程中的UI组件怎么办？
所以Android 就为我们提供了handler

Handler相关API如下：

1、Message:消息

1、可以理解为线程间通讯的数据单元，可通过Message携带需要的数据。
2、创建对象：Message.obtain(what)
3、封装数据
public int what //id标识
public int arg1
public int arg2
public Object obj

2、Handler：处理器

1、Handler是Message的处理器，同时也负责消息的发送和移除的工作。
2、发送即时消息：sendMessage(Message message)
3、发送延时消息：sendMessageDelayed(Message msg,long time)
这里所说的延时消息是指，消息发送后，延时处理.也是立即发送，只是延时处理了而已。
4、handlerMessage(Message msg) 回调方法
5、移除还未处理的消息：removeMessages(int what)
6、移除所有未处理的消息 removeCallbacksAndMessages(null)

3、MessageQueue:消息队列

1、用来存放通过Handler发送的消息
2、它是一个按Message的when排序的优先级队列。when就是指的时间，发送的如果是即时消息，那么when就是当前时间，如果发送的是延时消息，那么就是当前时间+延时的时间

4、Looper(钩子)：循环器

1、负责循环取出MessageQueue里面的当前需要处理的Message
2、交给对应的Handler进行处理
3、处理完后，将Message缓存到消息池中，以备复用。

Handler消息机制的原理图一

Handler消息机制的原理图二

看下面的一个例子理解handler的：

具体代码：

public class HandleActivity extends AppCompatActivity implements View.OnClickListener {
    private TextView tv_text;
    private Button btn;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handle);
        tv_text = findViewById(R.id.tv_text);
        btn = findViewById(R.id.btn);
        btn.setOnClickListener(this);
    }

    Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(@NonNull Message msg) {
            if (msg.what == 0x00) {
                tv_text.setText("我是第二条内容");
            }
            return false;
        }
    });

    @Override
    public void onClick(View v) {
        //创建子线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.sendEmptyMessage(0x00);
            }
        }).start();
    }
}

具体思路就是：在点击按钮时,发送一个消息给handler,再由handler更新UI组件
总结：Handler是Android中提供的一个消息处理的机制

1. 在任意线程中发送消息
2. 在主线程中获取并处理消息

通过handler消息机制，实现进度条的功能：

xml布局如下：

<ProgressBar
        android:id="@+id/progress_bar"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        style="@style/Widget.AppCompat.ProgressBar.Horizontal"
        android:max="60"
        />

Activity中代码：

public class HandleActivity extends AppCompatActivity{
	private ProgressBar progress_bar;
    private static final int TIME=60;//定义时间长度为60秒
    private int mProgressStatus=0; //定义完成的进度
    private final int TIMER_MSG=0X00; //声明消息代码
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handle);
		//获取进度条组件
        progress_bar = findViewById(R.id.progress_bar);
        //启动进度条
        handler.sendEmptyMessage(TIMER_MSG);
}
	//创建handler对象，实现1秒钟更新一次进度
	Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(@NonNull Message msg) {
            if (TIME-mProgressStatus>0){ //当前进度大于0
                mProgressStatus++; //进度加一
                progress_bar.setProgress(TIME-mProgressStatus);//更新进度
                handler.sendEmptyMessageDelayed(TIMER_MSG,1000);//一秒后发送消息
            }else {
                Toast.makeText(HandleActivity.this, "时间到啦，游戏结束！", Toast.LENGTH_SHORT).show();
            }
            return false;
        }
    });
}

Message语法：

1. 使用Message.obtain或Handler.obtainMessage()方法获取message
2. 携带int型信息，优先使用Message的arg1和arg2属性
3. 使用Message.what来标记信息

Message对象的属性有：

1. arg1,arg2整型
2. obj Object类型
3. replyTo 发送到何处
4. what自定义的消息代码

Looper对象的创建：
handler在主线程中 是系统自动创建Looper对象
如果在子线程中创建Handler对象，则要先手动创建Looper对象。
代码如下：

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

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_looper);

        new Thread(new Runnable() {
            @Override
            public void run() {
                //初始化Looper对象
                Looper.prepare();
                Handler handler = new Handler(new Handler.Callback() {
                    @Override
                    public boolean handleMessage(@NonNull Message msg) {
                        Log.e(TAG, "handleMessage: " + String.valueOf(msg.what));
                        return false;
                    }
                });
                Message message = handler.obtainMessage(); //获取Message
                message.what = 0x4; //设置消息代码
                handler.sendMessage(message);
                //启动looper
                Looper.loop();
            }
        }).start();
    }
}

一、使用Handler实现异步工作

具体代码如下

public class GetWorkActivity extends AppCompatActivity {
    private Button btn_get;
    private TextView tv_content;
    private ProgressBar progressBar;
    private Button btn_handler_get;
    private Handler handler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {//在主线程执行
            super.handleMessage(msg);
            //在handlerMessage中处理消息
            if (msg.what == 1) {
                String result = (String) msg.obj;
                tv_content.setText(result);
                progressBar.setVisibility(View.GONE);
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_get_work);
        btn_get = findViewById(R.id.btn_get);
        tv_content = findViewById(R.id.tv_content);
        progressBar = findViewById(R.id.progressBar);
        btn_handler_get = findViewById(R.id.btn_handler_get);
        btn_get.setOnClickListener(new MyOnClick());
        btn_handler_get.setOnClickListener(new MyOnClick());
    }

    class MyOnClick implements View.OnClickListener {

        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.btn_get:
                    progressBar.setVisibility(View.VISIBLE);
                    GetOkHttp();
                    break;
                case R.id.btn_handler_get:
                    progressBar.setVisibility(View.VISIBLE);
                    GetHandlerOkHttp();
                    break;

            }
        }
    }


    private void GetOkHttp() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                OkHttpClient okHttpClient = new OkHttpClient();
                Request request = new Request.Builder()
                        .url("https://www.httpbin.org/get")
                        .build();
                try {
                    Response response = okHttpClient.newCall(request).execute();
                    String string = response.body().string();
                    runOnUiThread(new Runnable() {//子线程切换到主线程
                        @Override
                        public void run() {
                            tv_content.setText(string);
                            progressBar.setVisibility(View.GONE);
                        }
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }


    private void GetHandlerOkHttp() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                OkHttpClient okHttpClient = new OkHttpClient();
                Request request = new Request.Builder()
                        .url("https://www.httpbin.org/get")
                        .build();
                try {
                    Response response = okHttpClient.newCall(request).execute();
                    String string = response.body().string();
                    //在子线程创建Message对象
                    Message message = Message.obtain();
                    message.what = 1;//标识
                    message.obj = string;
                    //使用handler对象发送message
                    handler.sendMessage(message);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}