总体思想就是两个（多个）线程共享一块存储区域，它们并发地操作这块内存。

下面是我自己初步写的模拟程序。

这里仅贴上Hander, HandlerThread, Looper2

package com.zte.liu;

public class Handler {

private Looper2 looper = null;

public Handler(Looper2 looper){
this.looper = looper;
}

public Message obtainMessage(){
return new Message(this);
}

public Message obtainMessage(int id){
return new Message(id, this);
}

public void dispatchMsg(Message msg){
handleMessage(msg);
}

public Looper2 getLooper(){
return looper;
}

public void handleMessage(Message msg){//钩子函数
System.out.println(msg.getId());
}
}

public class HandlerThread implements Runnable{

public void run(){
Looper2.prepare();
Looper2.loop();
}

}

package com.zte.liu;

public class Looper2 {

private static Looper2 looper = null;
private MessageQueue mQueue;
private Looper2(){
mQueue = new MessageQueue();
}

public static void prepare(){
if(looper == null){
looper = new Looper2();
}
}

public static Looper2 myLooper(){
prepare();
return looper;
}

public MessageQueue getQueue(){
return mQueue;
}

public static final void loop(){
System.out.println("loop begin...");
Looper2 looper = myLooper();
MessageQueue queue = looper.mQueue;
if(looper == null) {
return;
}
while(true){
System.out.println("----queue size ="+queue.size());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message msg = (Message)queue.next();
if(msg != null){
if(msg.getHandler() == null)return;
else{
msg.getHandler().dispatchMsg(msg);
Message.recycle(msg);
}
}
}
}
}