Android---Handler消息处理机制
搞Android的人都知道。android是不同意你在子线程中更新UI操作的。这主要出于线程安全方面的考虑。通常的做法是在主线程中创建一个Handler对象,在子线程中创建一个Message对象。该Message对象中封装一些更新UI操作的数据,通过Handler的sendMessage方法发送出去,主线程利用Handler的handleMessage方法来对该Message进行对应的处理。但发现没有,子线程调用Handler的sendMessage发出Message之后,消息是怎么传递到主线程的handleMessage方法里面进而进行处理的呢。接下来我们从源代码角度慢慢进行分析:
先来看看寻常我们是怎么使用handler的:
实例1:
public class MainActivity extends Activity { public Handler mHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mHandler = new Handler(){ @Override public void handleMessage(Message msg) { switch (msg.what) { case 1: System.out.println("接收到空消息"); break; default: break; } } }; new Thread(new Runnable() { @Override public void run() { mHandler.sendEmptyMessage(1); } }).start(); } }
解释:
能够看到。在子线程中我们使用的是主线程的Handler来进行sendMessage的,那么问题来了。子线程中能够存在自己的Handler么?而且用这个Handler来sendMessage?以下我们进行測试:
实例2:
public class MainActivity extends Activity { public Handler mHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mHandler = new Handler(){ @Override public void handleMessage(Message msg) { switch (msg.what) { case 1: System.out.println("接收到空消息"); break; default: break; } } }; new Thread(new Runnable() { @Override public void run() { Handler handler = new Handler(); handler.sendEmptyMessage(1); } }).start(); } }
解释:
这段程序我们调用的是自己的子线程自己的Handler,执行之后报了下面错误:
E/AndroidRuntime(963): java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
意思就是说在没有调用Looper.prepare()之前是不同意创建Handler对象的,这一点我们能够从Handler的构造函数中查看原因:
下面是Handler的构造函数源代码:
public Handler() { this(null, false); } public Handler(Callback callback, boolean async) { if (FIND_POTENTIAL_LEAKS) { final Class<? extends Handler> klass = getClass(); if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) && (klass.getModifiers() & Modifier.STATIC) == 0) { Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName()); } } //从ThreadLocal获取到Looper对象,这个对象是由Looper.prepare()函数创建而且加入到ThreadLocal中的 mLooper = Looper.myLooper(); if (mLooper == null) { <span style="color:#ff6666;">throw new RuntimeException( "Can't create handler inside thread that has not called Looper.prepare()");</span> } //获得Looper对象中的MessageQueue mQueue = mLooper.mQueue; mCallback = callback; mAsynchronous = async; }
解释:
抛出异常原因在于mLooper为null,而mLooper是一个Looper对象,这个对象是通过Looper的static方法myLooper从ThreadLocal中获取的。而创建Looper对象是由Looper的static方法prepare()实现的,而且将其增加到了ThreadLocal中。
因此我们找到了抛出异常的原因。也就是Looper对象为null。正如异常中所提示的一样,须要调用Looper.prepare()来创建Looper对象。
我们来查看Looper的static方法prepare源代码:
public static void prepare() { prepare(true);//创建子线程的Looper对象的时候,此处始终为true。可是待会会发现主线程的Looper对象在创建的时候此參数值是false } 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)); }
解释:
从源代码中我们看到在创建Looper对象之前先查看ThreadLocal中是否已经存在一个Looper对象。一个线程仅仅能创建一个Looper对象,假设多次创建Looper会抛异常。假设不存在的话,调用new Looper(true)创建当前线程的Looper对象,而且将其set到ThreadLocal中(在此多少能够发现ThreadLocal事实上是一个Map型的数据结构实现的,其源代码分析以后补上),来吧,该看看new Looper(true)究竟做了写什么事的时候了,源代码例如以下:
private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed);//创建了一个MessageQueue消息队列 mRun = true; mThread = Thread.currentThread(); }
解释:
非常easy,就是创建了一个MessageQueue而且将mThread设置为当前线程;
好了,至此我们创建了Looper对象。那么我们把Looper.prepare()增加到实例2的Handler handler = new Handler( )之前,看看会有什么事发生吧:
实例3:
public class MainActivity extends Activity { public Handler mHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mHandler = new Handler(){ @Override public void handleMessage(Message msg) { switch (msg.what) { case 0: System.out.println("1: "+Thread.currentThread()); break; default: break; } } }; new Thread(new Runnable() { @Override public void run() { Looper.prepare(); Handler handler = new Handler(){ @Override public void handleMessage(Message msg) { System.out.println("2: "+Thread.currentThread()); } }; handler.sendEmptyMessage(0); mHandler.sendEmptyMessage(0); } }).start(); } }
解释:
输出结果:1: Thread[main,5,main]
发如今我们的输出信息中,并没有输出:子线程中handleMessage的信息
原因事实上也非常easy:你如今仅仅是有Looper对象了,可是你并没有对Looper对象进行不论什么操作,就像你非常有钱,可是你不花这些钱,那钱还有什么用呢?那该怎么用呢?要想找到这个问题的答案,我们须要分析主线程中是怎么创建Looper对象以及怎么使用这个Looper对象的呢?
我们知道应用程序是通过ActivityThread主线程来创建的,为什么这样子说呢?看看源代码就知道啦:
public static void main(String[] args) { SamplingProfilerIntegration.start(); // CloseGuard defaults to true and can be quite spammy. We // disable it here, but selectively enable it later (via // StrictMode) on debug builds, but using DropBox, not logs. CloseGuard.setEnabled(false); Environment.initForCurrentUser(); // Set the reporter for event logging in libcore EventLogger.setReporter(new EventLoggingReporter()); Security.addProvider(new AndroidKeyStoreProvider()); Process.setArgV0("<pre-initialized>"); Looper.prepareMainLooper();//创建Looper对象 ActivityThread thread = new ActivityThread(); thread.attach(false); if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler(); } AsyncTask.init(); if (false) { Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread")); } Looper.loop();//使用Looper对象中的MessageQueue来进行消息处理 throw new RuntimeException("Main thread loop unexpectedly exited"); }
解释:
由于这个类里面有我们苦苦想要寻找的main函数,可能你曾经也会疑惑android程序究竟是怎么启动的呢?如今明确了吧,入口函数main在这里呢,来看看里面我们可能熟悉的代码吧。Looper.prepareMainLooper()有点类似于我们之前见过的Looper.prepare()吧,显然他也是用来创建一个Looper对象而且放入ThreadLocal里面的。仅仅只是他是在主线程中创建的:
public static void prepareMainLooper() { <span style="color:#ff6666;">prepare(false);//这里的參数值是false,子线程创建Looper的prepare參数值是true</span> synchronized (Looper.class) { if (sMainLooper != null) { throw new IllegalStateException("The main Looper has already been prepared."); } sMainLooper = myLooper(); } }
解释:
在有了Looper对象之后。main方法中的Looper.loop()就是利用Looper对象中的MessageQueue来进行消息接收和处理的。源代码例如以下:
public static void loop() { final Looper me = myLooper();//获得Looper对象 if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } <span style="color:#ff6666;">final MessageQueue queue = me.mQueue;//获得Looper对象中的MessageQueue</span> // 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(); //採用死循环的方式从MessageQueue中取出消息 for (;;) { <span style="color:#ff6666;"> Message msg = queue.next(); // might block</span> 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); } //调用dispatchMessage来进行消息的处理 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.recycle(); } }
解释:
详细过程是:
(1)首先通过myLooper( )静态方法获取到Looper对象;
(2)通过获取到的Looper对象来获取到该对象中的MessageQueue消息处理队列;
(3)採用死循环的方式对消息队列中的每一个消息调用此消息所在的handler(通过msg.target获取此handler)的dispatchMessage方法进行处理;
(4)消息处处理结束后调用recycle方法回收消息;
这里最重要的方法当然就是dispatchMessage消息处理和消息回收函数啦,接下来我们先分析一下消息是怎么传递到MessageQueue队列中的。随后再来分别来看看究竟在dispatchMessage和recycle这两个函数中做了什么?
要想处理消息,首先你得有消息吧。就像你想花钱一样,首先你总得有钱吧,handler机制中,消息是从哪来的呢?
非常显然从实例中我们能够看出,我们都是通过handler的sendEmptyMessage方法来发送消息的,在handler中存在非常多发送消息的方法,可是归根结底他们最后都会调用sendMessageAtTime方法的(无论你是採用Runnable的post机制还是採用Message的send机制),源代码例如以下:
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); }解释:
这种方法有两个參数。一个是想要传递给主线程的Message对象,uptimeMillis表示我们发送消息的时间,假设调用的不是sendMessageDelayed的话。uptimeMillis的值为0。在消息队列非空的前提下调用enqueueMessage将消息增加到队列中;
我们来看看enqueueMessage的源代码:
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { msg.target = this; if (mAsynchronous) { msg.setAsynchronous(true); } return queue.enqueueMessage(msg, uptimeMillis); }解释:
非常easy。他就是直接调用了MessageQueue队列中的enqueueMessage入队方法,来看MessageQueue里面的enqueueMessage方法源代码:
boolean enqueueMessage(Message msg, long when) { if (msg.isInUse()) { throw new AndroidRuntimeException(msg + " This message is already in use."); } if (msg.target == null) { throw new AndroidRuntimeException("Message must have a target."); } synchronized (this) { if (mQuitting) { RuntimeException e = new RuntimeException( msg.target + " sending message to a Handler on a dead thread"); Log.w("MessageQueue", e.getMessage(), e); return false; } 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; }解释:
这里我们仅仅讨论核心代码。由于要插入Message对象到队列。所以我们必须找到队尾元素的位置。而这个位置在上面的源代码是通过p的指针值是否为空来进行推断的,假设p本身为空的话,说明p已经到达了队尾,我们仅仅须要将该Message对象插入到p之后就可以啦,假如队列本身为空的话,那么p本身就是队尾。直接插入;假如队列本身不为空的话。须要遍历整个队列。找到队尾元素就可以啦,然后插入,我们能够看到。MessageQueue的队列是由单链表来实现的。
好了,这下子Message对象增加到了MessageQueue中啦,随后就是我们该怎么处理的问题啦;
查看Handler.java源代码中的dispatchMessage方法:
public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); } }
解释:
在正式分析此方法之前先补充一点。Handler支持两种消息类型。Runnable和Message,因此发送消息提供了post(Runnable r)和sendMessage(Message msg)两个方法。Message中的callback属性存储的就是Runnable对象;详细分析:
(1)首先查看该Message的callback字段是否为null,即查看此消息是否存在Runnable属性值(该值是通过post方法将其增加到Message的callback中的)。有的话则运行handleCallback方法。该方法会运行Runnable的run方法,源代码例如以下:
private static void handleCallback(Message message) { message.callback.run(); }(2)假设Message的callback字段为null的话,则查看是否存在外部的Callback类型对象,这个值是在创建Handler的时候通过构造函数传递进来的,假设存在的话运行该Callback对象的handleMessage方法;
(3)假设既不存在Runnable对象。又不存在外部的Callback对象的话,则直接运行handler自身的handleMessage方法,这种方法须要我们在new Handler之后进行重写,由于Handler本身是没有实现这种方法的。
public void handleMessage(Message msg) { }好了,消息已经处理结束啦,接下来我们就该回收该消息啦。也就是Looper.loop( )方法所运行的最后一句代码,msg.recycle( ),再次回到了源代码级别查看:
public void recycle() { clearForRecycle();//将Message的各种标识位所有归位 synchronized (sPoolSync) { if (sPoolSize < MAX_POOL_SIZE) { next = sPool; sPool = this; sPoolSize++;//将该消息返回给消息缓冲池 } } }
void clearForRecycle() { flags = 0; what = 0; arg1 = 0; arg2 = 0; obj = null; replyTo = null; when = 0; target = null; callback = null; data = null; }解释:
释放消息前首先将消息里面的各个消息标识位归位。随后将该消息增加到消息缓冲池中,以备下次我们使用消息的时候能够直接调用Message.obtain( )方法来获取消息。这样子就不用new Message( )啦,从而降低了new对象的时空开销,这就是缓冲机制的优点,由于缓冲池里面的全部消息对象是能够反复使用的。仅仅是在使用的时候进行必要标识位的设置就可以,看看Message的obtain方法就一目了然啦:
public static Message obtain() { synchronized (sPoolSync) { if (sPool != null) { Message m = sPool; sPool = m.next; m.next = null; sPoolSize--; return m; } } return new Message(); }解释:
我们能够发现,仅仅有当消息缓冲池为null的时候我们才会new Message出来,假设消息缓冲池不为空的话,直接获取缓冲池中的第一个,而且让缓冲池中的消息个数降低1就可以;
至此,整个消息处理过程已经结束了。
那么我们应该知道怎么改动实例3让他可以输出:子线程中handleMessage的信息
实例4:
public class MainActivity extends Activity { public Handler mHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mHandler = new Handler(){ @Override public void handleMessage(Message msg) { switch (msg.what) { case 0: System.out.println("1: "+Thread.currentThread()); break; default: break; } } }; new Thread(new Runnable() { @Override public void run() { Looper.prepare(); Handler handler = new Handler(){ @Override public void handleMessage(Message msg) { System.out.println("2: "+Thread.currentThread()); } }; handler.sendEmptyMessage(0); mHandler.sendEmptyMessage(0); Looper.loop(); } }).start(); } }区别就是添加了Looper.loop( )这句代码而已。
输出结果:
2: Thread[Thread-120,5,main]
1: Thread[main,5,main]
究竟,我们能够做做总结啦。看看Handler消息处理机制中究竟用到些什么?
1. Looper
(1)创建消息循环
prepare( )用于创建Looper对象,而且保存到ThreadLocal中;
(2)获得消息循环对象
myLooper( ),採用ThreadLocal的get方式获取存储在ThreadLocal里面的消息循环对象;
(3)開始消息循环
详细过程:
首选获取MessageQueue里面的队头Message
接着调用该Message所在handler的dispatchMessage方法。最后在dispatchMessage里面调用handlerMessage方法
消息使用完成之后将其增加到本地消息缓冲池中。以便下次使用,节省创建Message的开销
2. MessageQueue
每一个Looper对象相应一个MessageQueue队列,他是消息的存储区,向Handler发送的消息终于都会存储到该队列中
(1)消息入队
消息入队採用的方法是enqueueMessage( )。首先会查看队列是否为空,假设为空。则直接入队就可以。假设非空须要轮询链表,依据when从低到高的顺序插入链表的合适位置。这里的队列是由单链表实现的;
(2)轮询队列
next( )用于获取MessageQueue中的Message
3. Handler
(1)获取消息
以obtain打头的方法,这些方法实现的功能就是从本地消息缓冲池中获取消息,这样做的目的就仅仅是为了提高时空效率,这些方法实际上还是调用的Message中的各种obtain方法
(2)发送消息
Handler支持两种消息类型,各自是Runnable和Message,他们发送消息的方法各自是以post打头的post(Runnable runnable)和以sendMessage(Message message),可是post方法中的Runnable对象在最后还是会被封装到Message中称为Message的属性callback的值,也就是说原则上还是自由Message这样的方式的,在调用各种sendMessage的时候。都会终于运行sendMessageAtTime。而在这种方法里面就会调用MessageQueue的enqueueMessage来将Message增加到队列中啦;
(3)处理消息
Handler中处理消息的開始方法是dispatchMessage,在这种方法里面会调用Handler本身的handleMessage方法。而这种方法是须要我们在创建Handler的时候重写的
4. Message
(1)创建消息
创建消息有两种方式。我们能够通过new Message( )的方式创建一个新的Message,也能够通过Message.obtain从本地消息缓冲池中获取一个消息,后者在时空上效率更高;
(2)释放消息
消息使用完成之后。调用recycle函数释放消息,将该消息增加到本地消息缓冲池中,以便下次使用;
以上就是Handler消息处理机制的主要内容了。我们也自己实现了一个子线程中的handler而且创建了子线程自己的MessageQueue,此外子线程可以通过loop方法处理传递给子线程的消息了。可是假设每次我们想让子线程实现这种功能的话,我们都必须利用Looper.prepare( )和Looper.loop( )方法将我们的子线程中的handler代码包裹起来。这样是不是太麻烦啦,这就导致了HandlerThread的出现,在下一篇。我们解说下HandlerThread的源代码分析。