自己动手写消息机制-蒲公英云

自己动手写消息机制

首先，我们先别管Android中的消息机制，我们先来看一个需求：

在主线程中启动一个子线程去做一些事情，我希望子线程在做完这些事情后唤醒主线程来做一些相应的动作。

先想想怎么实现这个功能。直接在子线程回调一个接口？显然不行！

要让主线程感知到子线程的事情是否做完了。一般来说，就是在子线程完成事情后发送一些消息给主线程，让主线程知道子线程已经完成了工作，然后主线程去做相应的处理。这样一来，主线程就要变成一个死循环，无限循环的从消息队列中获取从子线程来的消息，并处理。

SouthEast

图中，主线程是一个轮询线程，主线程要做的事情就是，不断从消息队列中获取消息，并做处理。子线程处理完相关的业务之后，发送一个消息到消息队列中。整个过程是异步的。

同步：主线程启动一个子线程，在子线程执行过程中，主线程等待子线程完成后才继续往下运行

异步：主线程启动一个子线程，在子线程执行过程中，主线程也在运行

我们建立一个Java项目，简单模仿一下Android的消息机制

SouthEast 1

Looper是用来将线程变成一个轮询线程

package com.zhanjixun;
import java.util.HashMap;
import java.util.Map;
public class Looper {
    private static Map<Long, Looper> mLoopers = new HashMap<Long, Looper>();
    private MessageQueue mQueue = new MessageQueue();
    private Looper() {
    }
    public static void prepare() {
        long id = Thread.currentThread().getId();
        if (mLoopers.get(id) != null) {
            throw new RuntimeException("这线程的Looper已经调用prepare()");
        }
        mLoopers.put(id, new Looper());
    }
    public static void loop() {
        while (true) {
            Message next = myLooper().getMessageQueue().next();
            if (next != null) {
                if (next.getTarget() == null) {
                    return;
                } else {
                    next.getTarget().handlerMessage(next);
                }
            }
        }
    }
    public static Looper myLooper() {
        Looper looper = mLoopers.get(Thread.currentThread().getId());
        if (looper == null) {
            throw new RuntimeException(Thread.currentThread().getName()
                    + "线程的Looper还没有调用prepare()");
        }
        return looper;
    }
    public MessageQueue getMessageQueue() {
        return mQueue;
    }
}

其中的MessageQueue是用来管理Message的队列数据结构，先进先出原则

package com.zhanjixun;
import java.util.LinkedList;
public class MessageQueue {
    private LinkedList<Message> mMsgs = new LinkedList<>();
    public void push(Message msg) {
        System.out.println("有消息进队列-->>>" + msg.toString());
        mMsgs.add(msg);
    }
    public Message next() {
        if (mMsgs.size() > 0) {
            Message removeFirst = mMsgs.removeFirst();
            System.out.println("有消息从队列被取出<<<---" + removeFirst.toString());
            return removeFirst;
        }
        return null;
    }
}

Message类是对要发送的消息的一个封装

package com.zhanjixun;
public class Message {
    public int what;
    public Object obj;
    private Handler target;
    public Handler getTarget() {
        return target;
    }
    public void setTarget(Handler target) {
        this.target = target;
    }
}

Handler负责发送Message以及轮询线程回调

package com.zhanjixun;
/**
 * Handler负责发送Message以及轮询线程回调
 * 
 * @author doudian
 *
 */
public class Handler {
    private Looper myLooper;
    /**
     * 创建Handler一定要在轮询线程中创建，因为创建的时候需要获取轮询线程的Looper
     */
    public Handler() {
        myLooper = Looper.myLooper();
    }
    public void sendMessage(Message message) {
        message.setTarget(this);
        myLooper.getMessageQueue().push(message);
    }
    public void handlerMessage(Message message) {
    }
}

最后在Main方法中调用试试看成果

package com.zhanjixun;
public class Main {
    public static void main(String[] args) {
        Looper.prepare();
        Handler handler = new Handler() {
            @Override
            public void handlerMessage() {
                System.out.println(" doing something in "
                        + Thread.currentThread().getName() + " thread");
            }
        };
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(" doing something in "
                        + Thread.currentThread().getName() + " thread");
                handler.sendMessage(new Message());
            }
        }).start();
        Looper.loop();
        throw new RuntimeException("主线程不小心停止了！");
    }
}