Handler机制大致结构:
对应关系:
1. 每个Thread对应一个Looper
2. 每个Looper对应一个MessageQueue
3. 每个MessageQueue对应N个Message
4. 每个Message对应一个Handler
测试类
目标:先在主线程执行一些操作,然后发起一个异步任务,再在主线程继续做其它操作,当异步任务完成后,再回调通知主线程做一些操作
要求:不使用任何Android系统的API
其实用Future也可以实现这点,但是,future的get操作是阻塞的,这意味着当你在主线程去获取异步任务的结果时,会阻塞主线程,这显然不是我们希望的!
好了,如果你有更好的实现方式,欢迎指点!这里我先上自己的测试类,让大家看看效果,然后再来分析具体的实现思路
package base.handler;
import base.thread.LogUtil;
/**
* 模拟子线程请求网络
* <p>
* Created by yutianran on 16/7/4.
*/
public class TestClient {
private MyHandler mainHandler;
public static void main(String[] args) {
new TestClient().test();
}
private void test() {
//初始化主线程Looper
MyLooper.prepare();
mainHandler = new MyHandler(new MyHandler.CallBack() {
@Override
public void handleMessage(MyMessage msg) {
// 刷新界面
String obj = (String) msg.obj;
LogUtil.print("刷新界面:" + obj);
}
});
//发起网络请求
LogUtil.print("在主线程发起一个网络请求");
NetThread netThread = new NetThread("http://baidu.com");
netThread.start();
LogUtil.print("在主线程继续其它操作");
//开始消息循环
MyLooper.loop();
}
//网络线程类
private class NetThread extends Thread {
private String url;
public NetThread(String url) {
this.url = url;
}
@Override
public void run() {
String body = getWebData(url);
MyMessage msg = new MyMessage();
msg.obj = body;
mainHandler.sendMessage(msg);
}
}
//执行网络请求
private String getWebData(String url) {
LogUtil.print("执行请求网络:" + url);
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
String body = "这是" + url + "的响应值";
LogUtil.print("请求网络成功:" + body);
return body;
}
}
输出:
自定义消息处理器
思路分析:
1. 首先我们仿照Android的Handler,给我们的自定义Handler定义了:阻塞队列、处理消息的回调、分发和发送消息的方法
2.然后在创建Handler时,我们获取了当前线程的Looper和MessageQueue
3. 最后,当我们发送消息的时候,将消息添加进之前得到的MessageQueue
package base.handler;
/**
* 消息处理器
* <p>
* Created by yutianran on 16/7/4.
*/
public class MyHandler {
private MyMessageQueue queue;// 用于进行线程间通信的阻塞队列
private CallBack callBack; // 处理消息的回调
public MyHandler(CallBack callBack) {
MyLooper looper = MyLooper.myLooper();
if (looper == null) {
throw new RuntimeException("在新开的线程中。创建MyHandler对象需要先调用MyLooper.prepare()方法。");
}
queue = looper.queue;
this.callBack = callBack;
}
//消息接收的回调
public interface CallBack {
void handleMessage(MyMessage msg);
}
//发送消息
public void sendMessage(MyMessage msg) {
msg.target = this;
queue.enqueueMessage(msg);
}
//派发消息
public void dispatchMessage(MyMessage msg) {
callBack.handleMessage(msg);
}
}
自定义消息循环器-Looper
思路分析:
1. 在Looper中,我们用一个ThreadLocal存储当前Looper的相关数据
2. 定义了一个消息队列,用来管理消息
3. 在prepare()时,用ThreadLocal存储Looper的数据;在myLooper时,读取ThreadLocal存储的Looper数据
4. 在loop()时,用一个死循环来不断的接受和分发消息
package base.handler;
/**
* 消息循环器
* <p>
* Created by yutianran on 16/7/4.
*/
public class MyLooper {
private static ThreadLocal<MyLooper> threadLocal = new ThreadLocal<>();
private static MyLooper myLooper;
public MyMessageQueue queue;//一个线程对应一个阻塞队列
private MyLooper() {
queue = new MyMessageQueue();
}
//为本线程准备对应的MyLooper对象
public static void prepare() {
if (threadLocal.get() != null) {
throw new RuntimeException(
"Only one MyLooper may be created per thread");
}
threadLocal.set(new MyLooper());
}
//获取当前线程相对应的Looper对象
public static MyLooper myLooper() {
return threadLocal.get();//当未调用prepare()方法时。ThreadLocal.get()方法返回的为null;
}
//这里启动消息循环
public static void loop() {
while (true) {
myLooper = myLooper();
MyMessageQueue mQueue = myLooper.queue;
MyMessage msg = mQueue.next();// take()方法是个阻塞方法。线程运行到此会阻塞住。以准备接收发过来的消息
msg.target.dispatchMessage(msg);
}
}
}
自定义消息实体和消息队列
下面的消息实体就没什么好说的了,主要就是一个入队和出队的方法
/**
* 消息实体
* <p>
* Created by yutianran on 16/7/4.
*/
public class MyMessage {
public int msg1;
public int msg2;
public int what;
public Object obj;
public MyHandler target;
public Runnable runnable;
}
package base.handler;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
* 消息队列
* <p>
* Created by yutianran on 16/7/4.
*/
public class MyMessageQueue {
private BlockingQueue<MyMessage> queue;
private boolean quit = false;
public MyMessageQueue() {
queue = new LinkedBlockingQueue<>();
queue.clear();
}
public boolean enqueueMessage(MyMessage msg) {
if (msg.target == null) {
throw new RuntimeException("消息必须有一个消息处理者");
}
try {
queue.put(msg);
} catch (InterruptedException e) {
e.printStackTrace();
}
return true;
}
public MyMessage next() {
MyMessage msg = null;
if (quit) {
return null;
}
try {
msg = queue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
return msg;
}
public synchronized void quit() {
quit = true;
}
}
这里的LogUtil其实也与Android无关:
public class LogUtil {
public static void print(String msg) {
System.out.println("Thread:" + Thread.currentThread().getName() + "\t" + System.currentTimeMillis() + "\t" + msg);
}
}
好了,我的自定义消息传递机制搞定!
菜鸟一枚,水平有限,欢迎大家指出博文中的不足之处,小鱼将不胜感激!@qq:630709658