动手实现Handler v1.3

Handler是一个消息的分发对象，进行消息的发送和处理。主要用于异步消息的通信。
Handler配合Looper是Android在单线程模型实现多线程通信的重要构件
单线程模型是指Android程序启动时会创建一个主线程，只有在主线程下才能更新UI，其他线程执行耗时操作然后交由主线程刷新页面。

• 多线程通信实现原理
  应用启动时，会自动初始化Lopper（如果是子线程必须自己创建Looper）
  然后将Looper丢到ThreadLocal中
  开启lopper.loop()死循环读取消息
  主线程中创建Handlerd对象的初始化函数从ThreadLocal拿到Looper中的messageQueue
  其他线程通过Handler对象向MessageQueue添加消息。
  looper从MessageQueue中获取消息，通过消息所属的handler对象分发消息
  如果消息有回调Runable对象就直接调用执行，否则交由handleMessage()方法处理

• 多生产者-单消费者
  这里多线程中的一个典型场景就是多生产者对应一个消费者。那么关键是通过什么保证了线程安全
  MessageQueue.java、Message.java
  生产者：enqueueMessage()
  synchronized (this-MessageQueue)
  message单向链表 -先进后出
  消费者：next()
  从单链表中取出消息，空就阻塞直到有消息进入
  取出message并更新消息队列单链表的节点，线程安全

  当消费线程消费速度大于生产速度时，便阻塞在loop的queue.next()中的nativePollOnce()方法里。此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生来唤醒主线程工作。

• Android中为什么主线程不会因为Looper.loop()里的死循环卡死？
  Looper.java

• 为什么采用死循环
  既然Android中采用了单线程模型，而我们知道线程执行完毕就会自动结束。而我们的应用需要一直响应用户操作，不能打开就自动关闭了。所以采用了死循环

• 系统服务AMS如何与应用的主线程进行交互
  在进入loop之前开启Binder线程用于接受系统AMS事件，然后Binder通过系统集成Handler的内部类向主线程发送Message

• Activity的生命周期是怎么实现在死循环体外能够执行起来的？
  H的handleMessage()接受不同的生命周期的message,执行不同的生命周期的逻辑

自己实现Handler多线程通信

MyLooper

public class MyLooper {
    /**
     * 当前线程的MyLooper变量
     */
    private static ThreadLocal sThreadLocal = new ThreadLocal<>();
    private MyMessageQueue mQueue = new MyMessageQueue();

    /**
     * 初始化looper对象，并将其存入线程中
     */
    public static void prepare() {
        sThreadLocal.set(new MyLooper());
    }

    /**
     * 从当前线程获取looper对象
     * @return
     */
    public static MyLooper getLooper() {
        return sThreadLocal.get();
    }

    public MyMessageQueue getQueue() {
        return mQueue;
    }

    /**
     * 轮询消息队列，分发消息
     */
    public void loop() {
        for (; ; ) {
            MyMessage message;
            message = mQueue.next();//阻塞直到获取消息
            message.target.dispatchMessage(message);//消息分发
        }
    }
}

MyHandler

public abstract class MyHandler {

    private final MyMessageQueue myQueue;

    public MyHandler() {
        MyLooper looper = MyLooper.getLooper();
        if (looper == null) {
            throw new IllegalArgumentException("current thread no MyLooper!");
        }
        /**
         * 从当前线程中的Looper对象中获取消息队列
         */
        myQueue = looper.getQueue();
    }

    /**
     * 向消息队列发送消息
     *
     * @param message
     */
    public void sendMessage(MyMessage message) {
        message.target = this;//记录消息发送者
        myQueue.enqueueMessage(message);
    }

    /**
     * 向消息队列发送回调函数
     *
     * @param callBack
     */
    public void post(Runnable callBack) {
        myQueue.enqueueMessage(getPostMessage(callBack));
    }

    private static MyMessage getPostMessage(Runnable callBack) {
        MyMessage message = new MyMessage();
        message.callback = callBack;
        return message;
    }

    /**
     * 分发消息
     *
     * @param message
     */
    public void dispatchMessage(MyMessage message) {
        if (message.callback != null) {
            handleCallback(message);
        } else {
            handleMessage(message);
        }
    }

    /**
     * 处理回调函数
     *
     * @param message
     */
    private static void handleCallback(MyMessage message) {
        message.callback.run();
    }

    /**
     * 处理消息
     *
     * @param message
     */
    public abstract void handleMessage(MyMessage message);
}

MyMessageQueue

public class MyMessageQueue {
    public volatile MyMessage mMessages;//保证线程可见性

    /**
     * 将消息加入消息队列
     *
     * @param msg
     * @return
     */
    public boolean enqueueMessage(MyMessage msg) {
        if (msg == null) {
            throw new IllegalArgumentException("Message must not null.");
        }
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        synchronized (this) {//线程安全
            if (mMessages == null) {
                mMessages = msg;
            } else {
                msg.next = mMessages;//先进后出的单链表，新消息加入到消息头
                mMessages = msg;
            }
        }
        return true;
    }
    
    //从消息列表中获取消息
    public MyMessage next() {
        MyMessage prevMsg = null;
        MyMessage msg;
        for (; ; ) {
            /**
             * 我们没法调用Jni的nativeOnePoll自动唤醒线程，只能空旋线程了
             * 每隔一秒检查一次消息队列中是否有新消息
             */
            do {
                msg = mMessages;
                if (msg == null) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } while (msg == null);

            synchronized (this) {//线程安全读取消息
                if (msg != null) {
                    prevMsg = msg;
                    mMessages = mMessages.next;//单链表删除消息
                    return prevMsg;
                }
            }
        }
    }
}

MyMessage

public class MyMessage {
    public MyMessage next;//链表节点下一个消息
    public MyHandler target;//消息发送的对象
    public Runnable callback;//回调函数
    public Object obj;
    public int what;
}

使用

MyHandler handler;
...
new Thread() {
            @Override
            public void run() {
                MyLooper.prepare();//添加looper到线程中
                handler = new MyHandler() {//初始化MyHandler
                    @Override
                    public void handleMessage(final MyMessage message) {
                        if (message.what == 1) {
                            runOnUiThread(new Runnable() {//在主线程提示消息
                                @Override
                                public void run() {
                                    Toast.makeText(MainActivity.this, message.obj.toString(), Toast.LENGTH_SHORT).show();
                                }
                            });
                        }
                    }
                };
                MyLooper.getLooper().loop();//开启loop轮训messageQueue
            }
        }.start();
...
        MyMessage message = new MyMessage();
        message.what = 1;
        message.obj = "hello world:" + event.value + "";
        handler.sendMessage(message);//发送消息