出现的原因
解决子线程不能不能执行主线程中操作(主要是更新UI)问题。
更深次原因:
Android机制下不允许将耗时操作放在主线程中执行(比如网络请求等),只能放在子线程中执行,如果在主线程中执行就会抛出异常( CalledFromWrongThreadException:Only the original thread thatcreated a view hierarchy can touch its views.),
void checkThread() { if (mThread != Thread.currentThread()) { throw new CalledFromWrongThreadException( "Only the original thread that created a view hierarchy can touch its views."); } }
而在执行这些操作之后(比如网络请求),往往会紧接着执行更新UI的操作,而Android机制下,更新UI操作必须在UI线程(UIThread)即主线程(ActivityThread)中执行,否则会导致程序无法响应即ANR,为了解决这种矛盾Android就产生了异步消息处理机制。
延伸:系统为什么不支持在子线程中更新UI?
这要是因为UI线程不是线程安全的,如果存在多线程并发访问可能会导致UI控件处于不可预期的状态。那么我们可能会问“为什么系统不对UI控件加锁呢?”这样会让UI访问的逻辑变得复杂;其次是锁机制会降低UI访问的效率,因为锁机制会阻塞某些线程的执行,而UI页面的渲染机制在开发中必须是优先得到执行的。所以最简单高效的方式就是采用单线程模式来执行UI操作。
机制概述
Android的消息机制主要是指的Handler的运行机制以及Handler所附带的MessageQueue和Looper的工作过程,其实三者实际上是一个整体,只不过我们在开发过程中比较多的接触Handler而已。
主要涉及到的类
Handler , Message ,MessageQueue ,Looper
Handler
主要操作: 将一个任务切换到指定的线程中去执行。
1, sendMessage(msg,updataTime)发送消息到子线程中的MessageQueue
2, handMessage(msg)在主线程接收子线程中发送的数据
其他操作:
1,Handler创建时会采用当前线程的Looper来构建内部的消息循环系统,如果当前线程没有Looper就会报错。
Message
传递消息和数据的载体
MessageQueue
主要功能:可以看做存储消息的队列,虽然名字叫消息队列,但其数据结构是一个单链表(这样插入和删除比较快)。
Looper
主要功能:循环器,检索消息队列中的消息
异步消息处理机制工作原理
Hanlder:
当Handler创建完毕后,这时候其内部的Looper以及MessageQueue就可以和Handler一起协同工作了,然后通过Handler的post方法将一个Runnable投递到Handler内部的Looper中去处理,也可以通过Handler的send方法发送一个消息,这个消息也是在Looper中去处理,其实post方法最终也会通过send方法来完成。send方法的工作过程是,最终在send方法中会调用MessageQueue的enqueueMessage方法,将这个消息添加到消息队列中。
public final boolean sendMessage(Message msg) { return sendMessageDelayed(msg, 0); }
public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); }
public boolean sendMessageAtTime(Message msg, long uptimeMillis) { MessageQueue queue = mQueue; if (queue == null) { RuntimeException e = new RuntimeException( this + " sendMessageAtTime() called with no mQueue"); Log.w("Looper", e.getMessage(), e); return false; } return enqueueMessage(queue, msg, uptimeMillis); }
MessageQueue:
MessageQueue是一个单链表结构,主要包含两个操作:插入和读取。读取操作的本身会伴随着删除操作,插入和读取对应的方法分别是enqueueMessage和next,其中enqueueMessage的作用是往消息列表中插入一条消息,而next的作用是从消息队列中取出一条消息,并将其从消息队列中移除。
next方法的主逻辑是:在next方法中有一个无限循环的方法for(;;){},如果消息队列中没有消息,那么next方法就会一直阻塞在这里。当有新消息添加到消息队列时,next方法就会返回这条消息并将其从单链表中移除。
boolean enqueueMessage(Message msg, long when) { if (msg.target == null) { throw new IllegalArgumentException("Message must have a target."); } if (msg.isInUse()) { throw new IllegalStateException(msg + " This message is already in use."); } synchronized (this) { if (mQuitting) { IllegalStateException e = new IllegalStateException( msg.target + " sending message to a Handler on a dead thread"); Log.w(TAG, e.getMessage(), e); msg.recycle(); return false; } msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; if (p == null || when == 0 || when < p.when) { // New head, wake up the event queue if blocked. msg.next = p; mMessages = msg; needWake = mBlocked; } else { // Inserted within the middle of the queue. Usually we don't have to wake // up the event queue unless there is a barrier at the head of the queue // and the message is the earliest asynchronous message in the queue. needWake = mBlocked && p.target == null && msg.isAsynchronous(); Message prev; for (;;) { prev = p; p = p.next; if (p == null || when < p.when) { break; } if (needWake && p.isAsynchronous()) { needWake = false; } } msg.next = p; // invariant: p == prev.next prev.next = msg; } // We can assume mPtr != 0 because mQuitting is false. if (needWake) { nativeWake(mPtr); } } return true; }
Looper:
Looper在Android 的消息机制中扮演者消息循环的角色,具体来说就是它会不停的从MessageQueue中查看是否有新消息,如果有新消息就会立即处理,否则就会一直阻塞在这里。
我们知道,handler的工作需要Looper,没有Looper的线程就会报错。Looper的创建很简单,通过Looper.prepare()即可为当前线程创建一个Looper,接着通过Looper.loop()来开启循环。
new Thread("#ThreadName") { @Override public void run() { super.run(); //创建Looper的准备 Looper.prepare(); Handler handler = new Handler(); //开始循环 Looper.loop(); } }.start();
/** * Run the message queue in this thread. Be sure to call * {@link #quit()} to end the loop. */ public static void loop() { final Looper me = myLooper(); if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } final MessageQueue queue = me.mQueue; // Make sure the identity of this thread is that of the local process, // and keep track of what that identity token actually is. Binder.clearCallingIdentity(); final long ident = Binder.clearCallingIdentity(); for (;;) { Message msg = queue.next(); // might block if (msg == null) { // No message indicates that the message queue is quitting. return; } // This must be in a local variable, in case a UI event sets the logger Printer logging = me.mLogging; if (logging != null) { logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what); } msg.target.dispatchMessage(msg); if (logging != null) { logging.println("<<<<< Finished to " + msg.target + " " + msg.callback); } // Make sure that during the course of dispatching the // identity of the thread wasn't corrupted. final long newIdent = Binder.clearCallingIdentity(); if (ident != newIdent) { Log.wtf(TAG, "Thread identity changed from 0x" + Long.toHexString(ident) + " to 0x" + Long.toHexString(newIdent) + " while dispatching to " + msg.target.getClass().getName() + " " + msg.callback + " what=" + msg.what); } msg.recycleUnchecked(); } }
loop方法的工作过程是:loop方法是一个死循环,唯一跳出循环的方式就是MessageQueue的next方法返回null。当Looper的quit方法被调用时,Looper就会调用MessageQueue的quit或者quitSafely方法来通知消息队列退出,当消息队列别标记为退出状态是,他的next方法就会返回null。也就是说Looper必须退出,loop方法会调用MessageQueue的next方法来获取新消息,而next是一个阻塞线程,当没有消息的时候,next方法会一直阻塞在哪里,这也导致loop方法会一直阻塞。如果MessageQueue的next方法返回了新消息,Looper就会处理这条消息;msg.target.dispatchMessage(msg),这里的msg.target就是发送这条消息的Handler对象,这样Handler发送的消息最终又交给他的dispatchMessage方法来处理(原来dispatchMessage(msg)是Handler的方法)。但这里不同的而是,Handler的dispatchMessage方法是在创建Handler时所使用的Looper中执行的,这样就成功地将代码逻辑切换到指定的线程中去执行了。
延伸:Looper除了prepare方法外,还提供了preparemainLooper方法,这个方法主要是给主线程也就是ActivityThread创建Looper使用的,其本质也就是通过prepare方法来实现的。由于主线程的Looper比较特殊,所以Looper提供了一个getMainLooper方法,可以通过它可以在任何地方获取到主线程的Looper。Looper也是可以退出的,Looper提供了quit和quitSafely来退出一个Looper,两者的区别在于:qiut会直接退出Looper,而quitSafely只是设定一个退出标记,然后把消息队列中已有消息处理完毕后才完全退出。Looper退出后,通过Handler发送的消息会失败,这时候Handler的send方法会返回false。
异步消息处理机制流程:
1, Handler通过sendMessage(msg,updatatime)向子线程中的MessageQueue插入一条消息,其实是在send方法中执行了enqueueMessage方法。
2, 然后MessageQueue的next方法就会返回这条消息给Looper,读取并从单列表中移除这条消息,这其中是Looper一直在无限循环的执行loop方法拿到next的返回值。
3, 这时候Looper收到消息就开始处理了,最终消息由Looper交由Handler处理,即Handler的disPatchMessage方法会被调用。
4, 这时候Handler就开始进去处理消息了,通过CallBack来创建Handler对象:Handler handler = new Handler(callBack);。最后调用Handler的handleMessage方法来处理消息。