【温故而知新】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() {
            @Override
            public void run() {
                //Looper，通常我们会写一个“死循环”来运行我们的代码，这样的循环我们称之为Looper
                do {
                    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() {
            @Override
            public void run() {
                //Looper
                do {
                    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() {
            @Override
            public void run() {
                //Looper
                do {
                    threadSleep(2 * 1000);
                    long timestamp = System.currentTimeMillis();
                    strQueue.enqueue(String.format("str:%d", timestamp));
                } while (true);
            }
        }.start();

        //消费者1线程
        new Thread() {
            @Override
            public void run() {
                setName("消费者1");
                //Looper
                do {
                    try {
                        String name = strQueue.next();
                        System.out.println(String.format("消费者1 消费%s", name));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } while (true);
            }
        }.start();

        //消费者2线程
        new Thread() {
            @Override
            public void run() {
                setName("消费者2");
                //Looper
                do {
                    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