【温故而知新】Android 消息机制/HandlerThread、Looper、Handler 的前置知识点_综合

生产者消费者模型

在这里插入图片描述
生产者与消息费者模型关键知识点如下
1、角色上主要有生产者、消息费、生产的产品，存放产品的容器
2、生产者负责生产产品，消费者负责消费产品
3、生产者生产产品后放到产品容器（缓存产品）中，消费者从产品容器取出产品去消费
4、物品通常是称之为消息或任务等，容器通常秒为消息队列或任务队列表等
5、生产者通道是在生产线程生产，消费者通常是在消费者线程消费

简而语之就是生产者负责生产产品，并放到产品容器中，消费者从容器取出并消费之

Java线程的创建与使用

在这里插入图片描述
JDK提供Thread来创建新的线程，并在线程中执行相关的逻辑，如下代码就是一个简单的使用示例

package com.company;import java.util.ArrayList;
import java.util.List;public class Main {public static void main(String[] args) {
//        case1();case2();}public static void case1() {new Thread() {@Overridepublic void run() {//Looper，通常我们会写一个“死循环”来运行我们的代码，这样的循环我们称之为Looperdo {System.out.println("do somethings..");try {sleep(1 * 1000);} catch (InterruptedException e) {e.printStackTrace();}} while (true);}}.start();}
}

Java线程下的生产者消费者

上面的内容有讲到了生产者消费者，还有Java的线程使用，接来看下生产者消费者的示例代码，如下代码有一个生产者线程/生产者不停的生产字符串，并放到字符串列表中，供两个消费者使用，两个消费者是在独立的消费线程消费字符串。字符串队列就是生产者消费者模型中的产品存放容器，为支持多线程下安全访问，列队的存取需要加锁

package com.company;import java.util.ArrayList;
import java.util.List;public class Main {public static void main(String[] args) {
//        case1();case2();}public static void case1() {new Thread() {@Overridepublic void run() {//Looperdo {System.out.println("do somethings..");try {sleep(1 * 1000);} catch (InterruptedException e) {e.printStackTrace();}} while (true);}}.start();}public static void case2() {StrQueue strQueue = new StrQueue();//生产者线程new Thread() {@Overridepublic void run() {//Looperdo {threadSleep(2 * 1000);long timestamp = System.currentTimeMillis();strQueue.enqueue(String.format("str:%d", timestamp));} while (true);}}.start();//消费者1线程new Thread() {@Overridepublic void run() {setName("消费者1");//Looperdo {try {String name = strQueue.next();System.out.println(String.format("消费者1 消费%s", name));} catch (InterruptedException e) {e.printStackTrace();}} while (true);}}.start();//消费者2线程new Thread() {@Overridepublic void run() {setName("消费者2");//Looperdo {try {String name = strQueue.next();System.out.println(String.format("消费者2 消费%s", name));} catch (InterruptedException e) {e.printStackTrace();}} while (true);}}.start();}public static void threadSleep(long ms) {try {Thread.sleep(ms);} catch (InterruptedException e) {e.printStackTrace();}}
}//产品容器，存放生产的字符串
class StrQueue {private List<String> mNameList = new ArrayList<>();public synchronized String next() throws InterruptedException {while (mNameList.size() == 0) {System.out.println(String.format("%s wait", Thread.currentThread().getName()));this.wait();// 线程在这里wait后会释放this对象的锁，然后下次被唤醒后，会接着这里开始继续执行下一行代码，所以需要再次判断列队的大小，确定继续读取内容，还是继续等待。假如没用while的逻辑，当有两个线程在这里wait，然后其它线程调enqueue后就会换醒它们，第一个被唤配的线程会先remove，然后第二个被唤醒后也做remove的话就数组越界了System.out.println(String.format("%s wake up", Thread.currentThread().getName()));}return mNameList.remove(0);}public synchronized void enqueue(String name) {if (name == null) {return;}mNameList.add(name);System.out.println(String.format("生产者1 生产:%s, size:%d", name, mNameList.size()));this.notifyAll();}
}

运行效果(终端输出日志)如下所示

消费者2 wait
消费者1 wait
生产者1 生产:str:1638845608864, size:1
消费者1 wake up
消费者1 消费str:1638845608864
消费者1 wait
消费者2 wake up
消费者2 wait
生产者1 生产:str:1638845610865, size:1
消费者2 wake up
消费者2 消费str:1638845610865
消费者1 wake up
消费者1 wait
消费者2 wait
生产者1 生产:str:1638845612865, size:1
消费者2 wake up
消费者2 消费str:1638845612865
消费者1 wake up
消费者1 wait
消费者2 wait
生产者1 生产:str:1638845614871, size:1

Android下的生产者消费者模型

Android的消息机制就是典型的生产者消费者模型，生产与消费产品就是的消息(Message)，我们先看来下对于Looper类的使用介绍，是不是很熟悉、很眼熟的感觉，就跟上面的示例代码结构差不多！

class LooperThread extends Thread {public Handler mHandler;public void run() {Looper.prepare();// 在当前线程创建的handler，绑定的就是当成的Looper，在任何线程、任何地方引用到该handler，就可以调用相关的接口，生产Message并可以post到跟当前线程绑定的消息队列中mHandler = new Handler(Looper.myLooper()) {public void handleMessage(Message msg) {// process incoming messages here，这里可以写post出去的消息的处理逻辑，还是在当前线程处理}};// Looper，在loop里边从消息列表获取消息，并消费，Looper对象里边维护着一个消息队列（产品容器）Looper.loop();}}

PS：HandlerThread就是上述示例代码的实现，从这个示例代码也能看出Handler 、Looper、Message是提供给用户层面的“接口”类，整个消息机制下的更底层的类如MessageQueue的接口是没有暴露给外部使用的。具体的细节我会再写相关的文档跟大家一起学习与交流
先回来继续扯生产者消息费模型，配着该模型向看
1、消费者就是Looper，消费线程就是创建Looper的线程，这里的消费主要是指从队列取出消息
2、生产者就是Handler，但这样更为扩展一点，就是Handler需要处理Message，Handler发布一个Message到Looper的消息队列就是生产一个消息的行为
3、MessageQueue就是产品容器，这里叫消息队列

继续分享【温故而知新】Android 消息机制/HandlerThread、Looper、Handler 在Java层的知识点

参考资料

Android 源码分析 —— Handler、Looper 和 MessageQueue
HANDLER
THREAD