Handler机制解析

Hanlder机制用于线程间通信,通常用于子线程给主线程发送消息更新UI

Handler 
Message的主要处理者,用于发送消息,接收处理消息 
Message 
消息,线程间通信的数据单元 
MessageQueue 
消息队列,用于存放消息,取出消息 
Looper 
循环器,Message和Handler的桥梁,循环取出MessageQueue的消息发送Handler

需要注意几点:

在创建Handler之前,需要调用Looper.prepare()方法,之所以平常使用未调用过,是因为android在程序启动时帮我们创建好了,具体代码在activityThread中的main()方法中,

public static void main(String[] args) {

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");

        SamplingProfilerIntegration.start();

        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        EventLogger.setReporter(new EventLoggingReporter());

        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());

        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        Process.setArgV0("<pre-initialized>");

 

        Looper.prepareMainLooper();//在此调用的Looper.prepare()

 

        ActivityThread thread = new ActivityThread();

        thread.attach(false);

        if (sMainThreadHandler == null) {

            sMainThreadHandler = thread.getHandler();

        }

        if (false) {

            Looper.myLooper().setMessageLogging(new

                    LogPrinter(Log.DEBUG, "ActivityThread"));

        }   

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

 

        Looper.loop();

 

        throw new RuntimeException("Main thread loop unexpectedly exited");

    }

 

因此我们在子线程使用Handler的时候,需要调用Looper.prepare()方法

class LooperThread extends Thread { 

      public Handler mHandler; 

 

      public void run() { 

          Looper.prepare(); 

 

          mHandler = new Handler() { 

              public void handleMessage(Message msg) { 

                  // process incoming messages here 

              } 

          }; 

 

          Looper.loop(); 

      } 

  } 

 

调用Looper.prepare()方法后只能确保在创建Handler的时候不报错,如果不调用Looper.loop()方法,则没有任何效果,同样,android在程序启动时,已经为我们做好了这一步

public static void main(String[] args) {

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");

        SamplingProfilerIntegration.start();

        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        EventLogger.setReporter(new EventLoggingReporter());    

        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());

        TrustedCertificateStore.setDefaultUserDirectory(configDir);

        Process.setArgV0("<pre-initialized>");

 

        Looper.prepareMainLooper();//在此调用的Looper.prepare()

 

        ActivityThread thread = new ActivityThread();

        thread.attach(false);

        if (sMainThreadHandler == null) {

            sMainThreadHandler = thread.getHandler();

        }

        if (false) {

            Looper.myLooper().setMessageLogging(new

                    LogPrinter(Log.DEBUG, "ActivityThread"));

        }

        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

 

        Looper.loop();//在此调用的Looper.loop()

 

        throw new RuntimeException("Main thread loop unexpectedly exited");

    }

 

Handler的工作原理

当我们启动程序的时候,android自动在ActivityThread中帮我们创建了Looper.prepare()方法,创建了Looper对象. 
在调用Looper.prepare()方法时,会创建Looper对象,当前线程会将Looper的对象保存,并且在Looper构造方法中,创建MessageQueue对象,也就是说一个Looper一个MessageQueue

 

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));

    }

 private Looper(boolean quitAllowed) {

        mQueue = new MessageQueue(quitAllowed);

        mThread = Thread.currentThread();

    }

 

Handler调用postMessage之类的方法,最后都会调用sendMessageAtTime()方法,其中有queue.equeueMessage(msg)方法,实际就是消息入列逻辑

public boolean sendMessageAtTime(Message msg, long uptimeMillis){ 

    boolean sent = false; 

    MessageQueue queue = mQueue; 

    if (queue != null) { 

        msg.target = this; 

        //该方法为将消息添加到MessageQueue

        sent = queue.enqueueMessage(msg, uptimeMillis); 

    } 

    else { 

        RuntimeException e = new RuntimeException( 

            this + " sendMessageAtTime() called with no mQueue"); 

        Log.w("Looper", e.getMessage(), e); 

    } 

    return sent; 

} 

final boolean enqueueMessage(Message msg, long when) { 

    if (msg.when != 0) { 

        throw new AndroidRuntimeException(msg + " This message is already in use."); 

    } 

    if (msg.target == null && !mQuitAllowed) { 

        throw new RuntimeException("Main thread not allowed to quit"); 

    } 

    synchronized (this) {    10    9

        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; 

        } 

        //将消息的时间传进来赋给Message

        msg.when = when; 

        Message p = mMessages;        0

        if (p == null || when == 0 || when < p.when) { 

            msg.next = p; 1

                //将要取出的消息

            mMessages = msg;    0

            this.notify(); 

        } else { 

            Message prev = null; 

            while (p != null && p.when <= when) { 

                prev = p; 

                p = p.next; 

            } 

            msg.next = prev.next; 

            prev.next = msg; 

            this.notify(); 

        } 

    } 

    return true; 

} 

 

由上面我们可以得知,其实MessageQueue并没有用集合将消息存储起来,而是mMessages对象表示当前待处理的消息,所谓的加入队列其实就是将所有的消息按时间进行排序,具体的操作就是根据Message的时间,去调用msg.next。 
从消息取出消息队列是通过Looper.loop(),实际上是一个死循环,不断调用MessageQueue.next方法,他其中的操作就是判断当前是否有需要处理的消息,如果有,则取出来,将下个消息成为mMessages,否则就进入阻塞状态,一直等待新消息的加入。

public static final void loop() { 

    Looper me = myLooper(); 

    MessageQueue queue = me.mQueue; 

    while (true) { 

        Message msg = queue.next(); // might block 

        if (msg != null) { 

            if (msg.target == null) { 

                return; 

            } 

            if (me.mLogging!= null) me.mLogging.println( 

                    ">>>>> Dispatching to " + msg.target + " " 

                    + msg.callback + ": " + msg.what 

                    ); 

            msg.target.dispatchMessage(msg); 

            if (me.mLogging!= null) me.mLogging.println( 

                    "<<<<< Finished to    " + msg.target + " " 

                    + msg.callback); 

            msg.recycle(); 

        } 

    } 

} 

 

在Looper.loop()方法中找到将要处理的消息后,会调用msg.target.disPatcheMessage()方法,msg.target就是Handler.也就是调用了Handler.disPatchMessage()方法,在这个方法中,会判断mCallBack是否为空,如果不为空调用callback,如果为空,则调用了handlerMessage()方法,至此整个消息处理完成

public void dispatchMessage(Message msg) { 

    if (msg.callback != null) { 

        handleCallback(msg); 

    } else { 

        if (mCallback != null) { 

            if (mCallback.handleMessage(msg)) { 

                return; 

            } 

        } 

        handleMessage(msg); 

    } 

} 

 

对于上条的mCallBack,是因为在创建Handler对象的时候可以传入一个CallBack对象,如果return true,下面的handlermessage就不会收到消息,反正则能收到消息

   

private Handler mHandler = new Handler(new Handler.Callback() {

        @Override

        public boolean handleMessage(Message msg) {

            //返回为true则下面的handlerMessage不能收到消息

            //返回false则下面的hanlderMessage能够收到消息

            return false;

        }

    }){

        @Override

        public void handleMessage(Message msg) {

            super.handleMessage(msg);

        }

    };

 

上一篇:【转】(四)unity4.6Ugui中文教程文档-------概要-UGUI Visual Components


下一篇:python中$和@基础笔记