自己动手写消息机制

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

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

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

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

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

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

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

 

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

 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("主线程不小心停止了！");
	}
}

 

 

运行结果

 

源代码：http://download.csdn.net/detail/zhanjixun/9582075
   

   写到这里大概就能明白整个消息机制的原理了：就是将主线程（也可以是其他子线程）变成一个死循环的线程，不断从队列中获取消息并处理；子线程处理一些业务，处理完毕就发送一个消息到消息队列中。

 

 

   有空在分析一下Android中消息机制的源码