Handler线程消息处理逻辑
2014-03-07 22:15
435 查看
转载请注明出处:http://blog.csdn.net/droyon/article/details/20732979
我们可以开辟Handler用于消息的处理。我们可以使用主线程looper进行消息的收发loop。也可以使用我们新开辟的异步线程。
主线程:
以及自定义线程。(自定义线程变成Handler异步处理消息的线程,需要先在run里先执行Looper.prepare创建MesssageQueue,然后Looper.loop()让线程进入无线循环)
这篇文档主要就是阐述Handler是如何处理消息的。
普通线程:执行完run方法,线程结束。(走完了线程的生命周期)[新建状态(New)、就绪状态(Runnable):、运行状态(Running):阻塞状态(Blocked)]
Handler线程:线程启动会进入一个无线循环体之中,每循环一次,从其消息内部取出一个消息,回调其相应的消息处理函数。执行完一个消息继续循环,如果消息队列为空,则线程暂停,直到消息队列中有了新的消息。
handler需要解决的问题如下:
1、需要包括一个消息队列,队列中的消息一般采用排队机制,即先到的消息先处理。
2、线程执行while (true)进行无线循环,循环中从消息队列中取出消息,并根据消息的来源,回调其消息处理函数。
3、其他外部线程可以向本线程发送消息,插入到消息队列中,消息队列必须加锁,即消息队列不能同时进行读写操作。
我们看一下在Android中,如何对Handler的这三个问题进行实现。
1、首先创建消息队列。外部程序通过Handler向线程发送消息,消息经由Handler传递到MessageQueue对象中。
MessageQueue是通过Looper执行prepare方法创建的。任何线程都会执行start方法,启动run方法。无论是Activity主线程还是HandlerThread开启的线程。
而我们的Looper.prepare方法正是在run方法中执行的。如下:
HandlerThread.java(不要忘记执行Looper.loop方法)
Looper.java
ps:何为线程本地存储(可参阅java 编程思想)。对于类的内部静态变量,无论进程中的那个线程访问,其内容总是相同的,因为在编译器内部为static静态变量单独分配了空间。线程本地存储正好相反,不同的线程访问得到不同的结果。
言归正传,Looper是对应线程的,一个线程只能有一个Looper对象,这是Looper定义的。第一次调用Looper.prepare方法,会sThreadLocal.get,得到null,这个时候会new一个Looper对象,并且给sThreadLocal.set上。同一线程再次调用prepare就会throw RuntimeException。
接着往下看,new Looper中做了什么?
在Looper的构造方法里,创建了MessageQueue。
2、让线程进入无限循环
执行Looper.loop方法。此方法实现如下:
2.1、这里首先调用myLooper返回当前Looper对象,该函数内部仅仅通过线程本地存储sThreadLocal.get获取。
2.2、while(true)进入无限循环。
2.2.1、调用MessageQueue.next方法取出队列中的Message。如果当前队列为空,则当前线程会被挂起,也就是说,在next方法内部处理挂起线程的逻辑。
2.2.2、如果message不为null,则回调msg.target.dispatchMessage函数,此处的target也就是msg对应的Handler。
关于target,逻辑如下:
Handler在构造Message时:
或者:
2.2.3、如果消息处理完成,会调用msg.recycle方法回收该Message对象占用的系统资源。因为Message类内部使用了一个数据池保存Message对象,从而避免了不停的创建和删除Message类对象。因此,每次处理完该Message,需要将Message对象表明为空闲状态,以便使该Message对象可以重用。
3、消息队列采用了排队的方式对消息进行处理,即先到的消息先处理,但如果消息本身指定了被处理的时刻,则必须等到该时刻才能处理。消息在MessageQueue中使用Message表示,对列中消息以链表的结构进行保存。Message中next变量指向下一个消息。
MessageQueue中有两个主要的函数,“取出消息” next方法,“增加消息”enquenceMessage方法。
next方法内部流程分三步:
3.1、调用nativePollOnce方法
MessageQueue的jni代码在framework/base/core/jni/android_os_MessageQueue.cpp中。
3.2、接下来执行synchronized (this) 包含的代码段。this被用作趋消息和写消息的锁。在enqueueMessage方法中也使用了synchronized (this) 进行代码同步。
此段代码取出消息,判断该消息的执行时间是否到达,如果到了,就返回该消息,并将mMessage置空。否则,尝试获取下一个消息。
3.3、如果mMessage为null,说明c环境中的消息队列没有可执行消息。因此执行mPendingIdleHandler列表中的空闲回调函数。
添加消息代码:
enqueueMessage
将参数msg赋值给mMessage。调用nativeWake(mPtr)。这是一个jni函数,其内部会将mMessage消息添加到C环境中的消息队列中,并且如果该线程处于wait状态,唤醒该线程。
。
Handler 的消息处理android实现,到此为止,我们在使用Handler时,一般实现其handleMessage方法。这是因为,在Message回调其target的dispatchMessage时会执行如下代码:
Handler.java
到此为止。如有不当之处,欢迎交流。
我们可以开辟Handler用于消息的处理。我们可以使用主线程looper进行消息的收发loop。也可以使用我们新开辟的异步线程。
主线程:
mHandler = new Handler(){ @Override public void handleMessage(Message msg) { super.handleMessage(msg); } };异步线程:
HandlerThread hdThread = new HandlerThread(""); hdThread.start(); mHandler = new Handler(hdThread.getLooper());
以及自定义线程。(自定义线程变成Handler异步处理消息的线程,需要先在run里先执行Looper.prepare创建MesssageQueue,然后Looper.loop()让线程进入无线循环)
newThread newT = new newThread(); newT.start(); new Handler(newT.mLooper);
class newThread extends Thread{ public Looper mLooper; public newThread(){} @Override public void run() { super.run(); Looper.prepare(); Looper newLoop = Looper.myLooper(); mLooper = newLoop; Log.d("hlwang","onCreate looper ..... newLooper is:"+mLooper); mLooper.loop(); } }
这篇文档主要就是阐述Handler是如何处理消息的。
普通线程:执行完run方法,线程结束。(走完了线程的生命周期)[新建状态(New)、就绪状态(Runnable):、运行状态(Running):阻塞状态(Blocked)]
Handler线程:线程启动会进入一个无线循环体之中,每循环一次,从其消息内部取出一个消息,回调其相应的消息处理函数。执行完一个消息继续循环,如果消息队列为空,则线程暂停,直到消息队列中有了新的消息。
handler需要解决的问题如下:
1、需要包括一个消息队列,队列中的消息一般采用排队机制,即先到的消息先处理。
2、线程执行while (true)进行无线循环,循环中从消息队列中取出消息,并根据消息的来源,回调其消息处理函数。
3、其他外部线程可以向本线程发送消息,插入到消息队列中,消息队列必须加锁,即消息队列不能同时进行读写操作。
我们看一下在Android中,如何对Handler的这三个问题进行实现。
1、首先创建消息队列。外部程序通过Handler向线程发送消息,消息经由Handler传递到MessageQueue对象中。
MessageQueue是通过Looper执行prepare方法创建的。任何线程都会执行start方法,启动run方法。无论是Activity主线程还是HandlerThread开启的线程。
而我们的Looper.prepare方法正是在run方法中执行的。如下:
HandlerThread.java(不要忘记执行Looper.loop方法)
public void run() { mTid = Process.myTid(); Looper.prepare(); synchronized (this) { mLooper = Looper.myLooper(); notifyAll(); } Process.setThreadPriority(mPriority); onLooperPrepared(); Looper.loop(); mTid = -1; }我们进入到Loop.prepare方法内。
Looper.java
if (sThreadLocal.get() != null) { throw new RuntimeException("Only one Looper may be created per thread"); } sThreadLocal.set(new Looper());其中ThreadLocal为线程本地存储。
ps:何为线程本地存储(可参阅java 编程思想)。对于类的内部静态变量,无论进程中的那个线程访问,其内容总是相同的,因为在编译器内部为static静态变量单独分配了空间。线程本地存储正好相反,不同的线程访问得到不同的结果。
言归正传,Looper是对应线程的,一个线程只能有一个Looper对象,这是Looper定义的。第一次调用Looper.prepare方法,会sThreadLocal.get,得到null,这个时候会new一个Looper对象,并且给sThreadLocal.set上。同一线程再次调用prepare就会throw RuntimeException。
接着往下看,new Looper中做了什么?
private Looper() { mQueue = new MessageQueue(); mRun = true; mThread = Thread.currentThread(); }
在Looper的构造方法里,创建了MessageQueue。
2、让线程进入无限循环
执行Looper.loop方法。此方法实现如下:
public static void loop() { Looper me = myLooper(); if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } 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(); while (true) { Message msg = queue.next(); // might block if (msg != null) { if (msg.target == null) { // No target is a magic identifier for the quit message. return; } long wallStart = 0; long threadStart = 0; // 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); wallStart = SystemClock.currentTimeMicro(); threadStart = SystemClock.currentThreadTimeMicro(); } msg.target.dispatchMessage(msg); if (logging != null) { long wallTime = SystemClock.currentTimeMicro() - wallStart; long threadTime = SystemClock.currentThreadTimeMicro() - threadStart; logging.println("<<<<< Finished to " + msg.target + " " + msg.callback); if (logging instanceof Profiler) { ((Profiler) logging).profile(msg, wallStart, wallTime, threadStart, threadTime); } } // 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(); } } }
2.1、这里首先调用myLooper返回当前Looper对象,该函数内部仅仅通过线程本地存储sThreadLocal.get获取。
2.2、while(true)进入无限循环。
2.2.1、调用MessageQueue.next方法取出队列中的Message。如果当前队列为空,则当前线程会被挂起,也就是说,在next方法内部处理挂起线程的逻辑。
2.2.2、如果message不为null,则回调msg.target.dispatchMessage函数,此处的target也就是msg对应的Handler。
关于target,逻辑如下:
Handler在构造Message时:
public final Message obtainMessage() { return Message.obtain(this); }
public static Message obtain(Handler h) { Message m = obtain(); m.target = h; return m; }
或者:
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) { Message msg = Message.obtain(); msg.what = what; return sendMessageDelayed(msg, delayMillis); }
2.2.3、如果消息处理完成,会调用msg.recycle方法回收该Message对象占用的系统资源。因为Message类内部使用了一个数据池保存Message对象,从而避免了不停的创建和删除Message类对象。因此,每次处理完该Message,需要将Message对象表明为空闲状态,以便使该Message对象可以重用。
3、消息队列采用了排队的方式对消息进行处理,即先到的消息先处理,但如果消息本身指定了被处理的时刻,则必须等到该时刻才能处理。消息在MessageQueue中使用Message表示,对列中消息以链表的结构进行保存。Message中next变量指向下一个消息。
MessageQueue中有两个主要的函数,“取出消息” next方法,“增加消息”enquenceMessage方法。
next方法内部流程分三步:
final Message next() { int pendingIdleHandlerCount = -1; // -1 only during first iteration int nextPollTimeoutMillis = 0; for (;;) { if (nextPollTimeoutMillis != 0) { Binder.flushPendingCommands(); } nativePollOnce(mPtr, nextPollTimeoutMillis); synchronized (this) { // Try to retrieve the next message. Return if found. final long now = SystemClock.uptimeMillis(); final Message msg = mMessages; if (msg != null) { final long when = msg.when; if (now >= when) { mBlocked = false; mMessages = msg.next; msg.next = null; if (false) Log.v("MessageQueue", "Returning message: " + msg); msg.markInUse(); return msg; } else { nextPollTimeoutMillis = (int) Math.min(when - now, Integer.MAX_VALUE); } } else { nextPollTimeoutMillis = -1; } // If first time, then get the number of idlers to run. if (pendingIdleHandlerCount < 0) { pendingIdleHandlerCount = mIdleHandlers.size(); } if (pendingIdleHandlerCount == 0) { // No idle handlers to run. Loop and wait some more. mBlocked = true; continue; } if (mPendingIdleHandlers == null) { mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)]; } mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers); } // Run the idle handlers. // We only ever reach this code block during the first iteration. for (int i = 0; i < pendingIdleHandlerCount; i++) { final IdleHandler idler = mPendingIdleHandlers[i]; mPendingIdleHandlers[i] = null; // release the reference to the handler boolean keep = false; try { keep = idler.queueIdle(); } catch (Throwable t) { Log.wtf("MessageQueue", "IdleHandler threw exception", t); } if (!keep) { synchronized (this) { mIdleHandlers.remove(idler); } } } // Reset the idle handler count to 0 so we do not run them again. pendingIdleHandlerCount = 0; // While calling an idle handler, a new message could have been delivered // so go back and look again for a pending message without waiting. nextPollTimeoutMillis = 0; } }
3.1、调用nativePollOnce方法
nativePollOnce(mPtr, nextPollTimeoutMillis);这是一个jni函数,其作用是从消息队列中取出一个消息。MessageQueue类内部本身没有保存消息队列,真正的消息队列保存在jni实现的c代码中。也就是说C环境中创建了一个NativeMessageQueue数据对象,这既是nativePollOnce函数第一个参数的意义。
private int mPtr; // used by native codemPtr是一个int型变量,在c中将会被强制转换为NativeMessageQueue对象,在C环境中,如果消息队列中没有消息,则当前线程被挂起(wait),如果有消息,则c代码将该消息赋值给java环境中Message对象。
MessageQueue的jni代码在framework/base/core/jni/android_os_MessageQueue.cpp中。
3.2、接下来执行synchronized (this) 包含的代码段。this被用作趋消息和写消息的锁。在enqueueMessage方法中也使用了synchronized (this) 进行代码同步。
此段代码取出消息,判断该消息的执行时间是否到达,如果到了,就返回该消息,并将mMessage置空。否则,尝试获取下一个消息。
3.3、如果mMessage为null,说明c环境中的消息队列没有可执行消息。因此执行mPendingIdleHandler列表中的空闲回调函数。
添加消息代码:
enqueueMessage
final boolean enqueueMessage(Message msg, long when) { if (msg.isInUse()) { throw new AndroidRuntimeException(msg + " This message is already in use."); } if (msg.target == null && !mQuitAllowed) { throw new RuntimeException("Main thread not allowed to quit"); } final boolean needWake; synchronized (this) { if (mQuiting) { RuntimeException e = new RuntimeException( msg.target + " sending message to a Handler on a dead thread"); Log.w("MessageQueue", e.getMessage(), e); return false; } else if (msg.target == null) { mQuiting = true; } msg.when = when; //Log.d("MessageQueue", "Enqueing: " + msg); Message p = mMessages; if (p == null || when == 0 || when < p.when) { msg.next = p; mMessages = msg; needWake = mBlocked; // new head, might need to wake up } else { Message prev = null; while (p != null && p.when <= when) { prev = p; p = p.next; } msg.next = prev.next; prev.next = msg; needWake = false; // still waiting on head, no need to wake up } } if (needWake) { nativeWake(mPtr); } return true; }
将参数msg赋值给mMessage。调用nativeWake(mPtr)。这是一个jni函数,其内部会将mMessage消息添加到C环境中的消息队列中,并且如果该线程处于wait状态,唤醒该线程。
。
Handler 的消息处理android实现,到此为止,我们在使用Handler时,一般实现其handleMessage方法。这是因为,在Message回调其target的dispatchMessage时会执行如下代码:
Handler.java
public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); } }
到此为止。如有不当之处,欢迎交流。
相关文章推荐
- Android之Handler在新线程中处理消息
- java.lang.RuntimeException: 将消息发送到死的线程上处理程序的处理程序 (android.os.Handler)
- 关于android Handler进行线程处理消息队列与线程队列线程无法停止的问题
- 在子线程创建handler进行处理消息
- 【Android开发】线程与消息处理-Handler消息传递机制之Looper
- Android之Handler在新线程中处理消息
- Handler消息处理分析(UI线程)
- Android线程之异步消息处理机制(二)——Message、Handler、MessageQueue和Looper
- Android:在子线程中更新UI,解析异步消息处理机制(Handler)
- Android Handler在新线程中处理消息
- Handler 、 Looper 、Message异步消息处理线程机制( hander消息机制原理)
- Android之Handler在新线程中处理消息
- Android异步消息处理线程之----Looper+MessageQueue+Handler
- 基于Handler的消息处理线程的缺点
- Android学习—— Handler 的消息发送,在新的线程处理消息
- 源码分析异步消息处理线程机制(Looper MessageQueue Handler Message)
- 下面的程序实现了在利用Handler在新线程当中处理消息的方法
- #Android笔记#线程与消息处理之Handler
- 主线程有多个Handler, 子线程发送消息由哪个handler处理
- Android 中消息处理机制-Looper、Handler、Thread(一)