其实这篇文章早写过了，只是当时发表在简述上了；今天补一下
1、子线程与主线程之间使用Handler
new Thread(new Runnable() {
@Override
public void run() {
Message message = new Message();
message.what = 0;
message.obj = "这是线程1发送的消息";
handler.sendMessageDelayed(message,0);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
Message message = new Message();
message.what = 1;
message.obj = "这是线程2发送的消息";
message.arg1 = 11;
message.arg1 =111;
handler.sendMessageDelayed(message,0);
}
}).start();
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0:
Log.i("KBein", "MainActivity--->handleMessage: 0---"+(String) msg.obj);
break;
case 1:
Log.i("KBein", "MainActivity--->handleMessage: 1---"+(String) msg.obj);
break;
}
}
};
2、子线程与子线程之间使用Handler
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0:
Log.i("KBein", "Main3Activity--->handleMessage: 接收 -- "+msg.obj);
break;
}
}
};
Looper.loop();
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
Log.i("KBein", "Main3Activity--->run: 发送");
Message msg = new Message();
msg.what = 0;
msg.obj = "----------";
handler.sendMessage(msg);
}
});
注意：这两个线程：thread1和thread2在执行start()方法是中最好设置一个时间间隔（如果是在同一个Acitvity中），否则可能会导致thread2中的handler对象空指针
我们先来对比这两份代码都是用Handler来进行传递消息，但明显发现主线程初始化Handler比在子线程中多了两个步骤：
Looper.prepare();
....
Looper.loop();
这是为什么呢？？？
首先我们来看一下不加Looper.prepare()会打印出什么日志：
02-19 16:30:55.884 27212-27227/com.kbein.rxjavastudy E/AndroidRuntime: FATAL EXCEPTION: Thread-897
Process: com.kbein.rxjavastudy, PID: 27212
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
at android.os.Handler.<init>(Handler.java:200)
at android.os.Handler.<init>(Handler.java:114)
at com.kbein.rxjavastudy.demo2.Main3Activity$1$1.<init>(Main3Activity.java:38)
at com.kbein.rxjavastudy.demo2.Main3Activity$1.run(Main3Activity.java:38)
at java.lang.Thread.run(Thread.java:818)
这里出现了一个运行时异常：Can't create handler inside thread that has not called Looper.prepare()
大致意思就是：无法在未调用Looper.prepare（）的线程内创建Handler
这里我们先看一下Handler的构造函数：
public Handler() { this(null, false); }
//这个无参构造没什么用看一下this(null,false)
public Handler(Callback callback, boolean async) {
// ...
Looper mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
出来了，这里的mLooper为空了，这点应该很明显了，大家应该都知道Looper这个类（不知道的也没关系，稍后会看Looper类源码）主要有三个作用：
1、创建消息队列MessageQueue
2、以当前线程的ThreadLocal为key,Looper为value映射到ThreadLocal类中的ThreadLocalMap中
3、loop()方法死循环从MessageQueue中取出按触发时间排序的message，再用message对象携带的Handler把这个message分发下去（message。handler.dispatchMessage(message)）
接下来我们回到上面的两个例子： 有点很奇怪哦，为什么在主线程中使用Handler不需要Looper.prepare()？？？？ 好(^o^)/~这里我们来具体的看一下Looper类
先贴出Looper类的构造函数： private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed);//初始化消息队列 mThread = Thread.currentThread();//得到当前线程 } 惊奇的发现他居然是private修饰的，也就是说我们要获取Looper对象是不能使用new（难受、、） 上面还记得报的那个运行时异常么：Can't create handler inside thread that has not called Looper.prepare()--->这里说明我们的Looper空，在没调用Looper.prepare()方法时为空， 所以prepare()方法一定做了初始化Looper的操作 不服，看源码： ``` public static void prepare() { prepare(true); }
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
```
看吧--->在prepare(boolean quitAllowed)方法中有个sThreadLocal.set(new Looper(quitAllowed));出现了new Looper()了吧。这里我把prepareMainLooper()源码也贴出来了，等会说它;
我们先看一下prepare(boolean quitAllowed)方法：
主要是将Looper对象加入到ThreadLocal类的静态内部类ThreadLocalMap中（ThreadLocalMap是一个以当前线程的ThreadLocal为key,Looper为value的map，而value则是一个ReferenceQueue）ThreadLocal随便代码不多，但水还是很深的，它主要是用于实现在不同的线程中存储线程私有数据，在new thread()线程实例的是会在它的init()方法中初始化ThreadLocalMap相关的数据。对于这个类主要了解它的set()和get()方法是用来从ThreadLocalMap中添加或者取去looper，这里就不详细说了。至此第一个问题在子线程中使用Handler要加Looper.prepare()方法大致就解决了。至于在子线程中实例化Handler对象之后还要调用Looper.loop()方法这一点后面会讲到。
接下来我们来讲一下为什么在主线程中使用Handler不需要Looper.prepare()和Looper.loop()这两个方法。
这就要看我们上面贴出来的prepareMainLooper()这个方法了，根据字面意思感觉很像是“准备主Looper”。我们来看看他是在哪儿调用了，我先把代码贴出来(是在AcitivityThread这个类中)
public static void main(String[] args) {
...
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
....
}
AcitivityThread这个类很厉害的，看到mian(String[] args)这个方法了么，这是程序的入口。所以这就出来了，我们在初始化程序的时候就已经给主线程初始化了一个Looper，所以我们在Activity中直接用Handler是没有问题的
这就是上面我们讨论到在子线程中使用Handler与在主线程中使用Handler不同区别的原因；但这里印出来一个问题，主线程会在main()方法中初始化Looper并且调用了Looper.loop()(大家应该知道Looper类中的loop()方法是一个死循环)，
那么问题来了，为什么主线程不会卡死阻塞？？（这个最后在提一下吧）
总结： Looper类:
1、构造函数--- 初始化一个MessageQueue、得到当前线程
2、loop()方法 --- 主要用于循环读取MessageQueue中的message，从MessageQueue中取出时间最近的massage,这个message中又有发送此消息的Handler对象，然后拿这个Handler对象调用它的dispatchMessage(msg)方法分发消息。源码中是这样写的 msg.target.dispatchMessage(msg);这个target就是message持有的handler实例；(稍后贴源码)
注意：此方法会先获取Looper对象，而Looper对象存放在TheadLocal中，因此如果是非主线程使用Handler一定先调用prepare()初始化Looper并加入到TheadLocal中，而主线程的Looper在程序初始化时就已经调用prepareMainLooper(),具体可参照：ActivityThread类。
MessageQueue类：
enqueueMessage();主要用于将消息加入消息队列并按执行时间（when）排序，等待Loop循环调用；MessageQueue这个类提供了很多方法，有些直接是调用native层，大致理论就是这样的：MessageQueue提供了一些方法去调用native层的MessageQueue，然后取出message（当然没有这么简单，哈哈）
Handler类：
1、构造函数--- 获取Looper对象，再从Looper对象中回去到MessageQueue的实例，这样一来Handler就持有了Looper和MessageQueue；
2、提供了一些Message的一些封装方法（这里就不详细说了）
3、用户调用handler对象的sendMessage方法，传入msg对象。handler通过调用MessageQueue的enqueueMessage方法将消息压入MessageQueue。enqueueMessage方法会将传入的消息对象根据触发时间（when）插入到messagequeue中。然后判断是否要唤醒等待中的队列。（这里要说明一点，message持有的Handler对象就是在Handler类中的enqueueMessage()方法初始化的）
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;//让每个message持有Handler对象
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
a. 如果插在队列中间。说明该消息不需要马上处理，不需要由这个消息来唤醒队列。
b. 如果插在队列头部（或者when=0），则表明要马上处理这个消息。如果当前队列正在堵塞，则需要唤醒它进行处理。如果需要唤醒队列，则通过nativeWake方法，往前面提到的管道中写入一个”W”字符，令nativePollOnce方法返回。
