Handler机制_handle yuan-CSDN博客

本文链接：https://blog.csdn.net/yuan_fang_yan/article/details/88535674

Hanlder作用

handler是更新UI界面的机制（线程间的信息传递），也是消息处理机制，可以用来发送和处理消息

Handler的使用

Handler handelr = new Handler(){
 @Override
  public void handleMessage(final Message msg) {
    //这里接受并处理消息
  }
};

实例一个Handler对象，并重写handlerMessage()方法，然后再调用他的send和post系列的方法，还支持延迟消息

Handler分析

我们可以看下创建Handler的源码：

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

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

Looper

从这里我们可以看到创建Handler的时候，Hanlder都会先去检查Looper是否为空。如果为空的话则会抛出异常。所以在创建Handler之前必须要先创建Looper

不过在平常创建Handler的时候，通常没有创建Looper。在使用的时候也没看见有异常，这个是因为主线程已经帮我们创建了Looper。在后面会说到。

创建一个完整的Handler是这样的：

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

  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提供Looper.prepare();来创建Looper，并且通过ThreadLocal来与当前的线程进行绑定

Looper.loop();

    /**
     * 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;

       //...

        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
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

           //...
            try {
                msg.target.dispatchMessage(msg);
                dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            //...

            msg.recycleUnchecked();
        }
    }

可以看出Looper.loop()是个死循环，不停的通过queue.next()获取消息，并通过msg.target.dispatchMessage(msg)将消息回调到Handler，msg.target就是消息的Handler对象。

queue.next()是MessageQueue中获取Message的方法。