android 详解Handler内部源码机制

handler是我们android开发一定会用到的,如果说你没用到,那你还说是做android开发的,谁都不信,上帝也不会相信的,但是如果只停留在使用上,而不去分析内部实现,如果你去面试问你这个都不会,估计不太好吧,至少在面试官的影响中肯定是减分的.

我们知道Handler里面会涉及到几个类,都说轮询也就是Looper,还有什么消息队列,就是MessageQueue,那么他们之间是什么关系呢? 那就去Handler源码中神游下.

首先从Handler构造函数入手,

/**
 * Default constructor associates this handler with the {@link Looper} for the
 * current thread.
 *
 * If this thread does not have a looper, this handler won't be able to receive messages
 * so an exception is thrown.
 */
public Handler() {
    this(null, false);
}

我们调用一个无参的构造函数,但是它是去调用二个参数的构造函数,这不是主要的,主要的是它上面的注释,意思是通过一个默认的构造函数创建一个Handler对象,而且是在当前线程,也就是说你在哪个线程中new Handler,还有就是如果这个线程中没有与之关联的Looper对象,那这个handler无法接受到消息,

那么在UI线程中创建了一个Handler,但是并没有创建Looper啊,有的,只是系统帮我们做了,在activity的启动的时候通过ActivityThread中的入口main()方法中,

public static void main(String[] args) {
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
    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());

    // Make sure TrustedCertificateStore looks in the right place for CA certificates
    final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
    TrustedCertificateStore.setDefaultUserDirectory(configDir);

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

    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false);

    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }

    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }

    // End of event ActivityThreadMain.
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
    Looper.loop();

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

Looper.prepareMainLooper();通过这个代码,就会去创建Looper对象了,点击进去,看到底干了什么事,

/**
 * Initialize the current thread as a looper, marking it as an
 * application's main looper. The main looper for your application
 * is created by the Android environment, so you should never need
 * to call this function yourself.  See also: {@link #prepare()}
 */
public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

看这个注释就知道了,在当前线程中创建一个Looper,它是应用启动的时候就创建了,所以你永远不需要调用这个方法.

它的第一行代码就是prepare(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));
}

你会发现这个方法是一个private修饰的,内部使用的,它是创建了一个Looper对象然后保存在ThreadLocal中去,ThreadLocal它的作用是可以在每个线程中存储数据的安全,比如你在A线程中发送了数据,B线程中发送了数据,怎么保证线程的数据不乱,就是通过ThreadLocal实现的,

现在回到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 that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

首先是Looper.myLooper()方法获取Looper对象,

/**
 * Return the Looper object associated with the current thread.  Returns
 * null if the calling thread is not associated with a Looper.
 */
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

看注释是返回与当前线程关联的Looper对象,如果调用线程与一个Looper没有关联，则为null.

mQueue = mLooper.mQueue;再看下这个是返回一个MessageQueue对象,就是消息队列,mQueue是在哪赋值的,

final MessageQueue mQueue;这是在Looper类中定义的成员变量,赋值是在构造函数中的,

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

从这可以看的出来,一个Looper对象对应一个MessageQueue，MessageQueue是一个链表的结构,那么我们在子线程中发送消息(Message),消息就入队列了,

/**
 * Pushes a message onto the end of the message queue after all pending messages
 * before the current time. It will be received in {@link #handleMessage},
 * in the thread attached to this handler.
 *  
 * @return Returns true if the message was successfully placed in to the 
 *         message queue.  Returns false on failure, usually because the
 *         looper processing the message queue is exiting.
 */
public final boolean sendMessage(Message msg)
{
    return sendMessageDelayed(msg, 0);
}

看这个注释,最终会调到这个方法:

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

enqueueMessage()方法就是把Message放入到队列中,

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

msg.targt = this,这是把Handler赋值给了Message.target,用来判断这个消息是从哪个Handler发送过来的,

queue.enqueueMessage(msg, uptimeMillis)这个就是真正把消息放入到哦队列中的,既然有消息入队列,我们都知道Looper是消息轮询的,轮询是Looper中的,

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

        final long traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        try {
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }

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

但是我们好像从来没有调用过这个方法啊,对吧,它是怎么去轮询这个MessageQueue队列中的消息呢?这是在ActivityThread中的main()方法倒数第二行代码被调用了,

if (false) {
    Looper.myLooper().setMessageLogging(new
            LogPrinter(Log.DEBUG, "ActivityThread"));
}

// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();

这就是为啥我们自己不手动调用loop()方法,如果有消息会怎么办,loop()方法中有一个重要的代码

try {
    msg.target.dispatchMessage(msg);
} finally {
    if (traceTag != 0) {
        Trace.traceEnd(traceTag);
    }
}

之前说了targete就是handler,调用dispatchMessage分发Message,

/**
 * Handle system messages here.
 */
public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

如果msg.callback==null,就调用handleMessage()处理这消息,那么这个消息处理是在子线程中还是主线程中呢,你这么想handler是异步消息处理机制,是更新UI的,如果是子线程中,能更新UI么,所以说这个消息处理一定是在主线程中,

现在花个图理解下:

其实这就是典型的多线程的生产者消费者模式,在子线程中生产(Message),在主线程中消费(Message).

现在几个常见的问题,也是面试常见的问题举例分析下:

1:我们都知道Handler的创建是在主线程,那么在子线程中能创建么,写个,

new Thread(){
    @Override
    public void run() {
        super.run();
        Handler handler = new Handler();
    }
}.start();

运行起来后发现报错了,

它说不能创建handler对象在子线程中,因为没有调用perpare()方法,之前我们也分析了这个方法,再把这个方法看下:

public static void prepare() {
    prepare(true);
}

调用带参数的prepare(true)

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对象的,所以说prepare()方法是创建Looper对象的,如果你创建Handler对象,只顾着发送消息,但是没有处理这个消息,那么队列中的消息是不是堆满了,对内存消息挺大,所以它就报错了,那解决的方法就是调用prepare()方法

new Thread(){
    @Override
    public void run() {
        super.run();
        Looper.prepare();
        Handler handler = new Handler();
    }
}.start();

2:handler可以在主线程中发送消息么.那是可以的,只是如果在主线程中发送消息,处理消息也在主线程中,那干嘛还用Handler.

3:能在子线程中更新UI么? 可以的

new Thread(){
    @Override
    public void run() {
        super.run();
        Looper.prepare();
        Handler handler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                Toast.makeText(getApplicationContext(), "在子线程中更新UI", Toast.LENGTH_LONG).show();
            }
        };
        handler.sendEmptyMessage(1);
        Looper.loop();
    }
}.start();

有二个必须条件:

1:必须调用Looper.prepare()方法创建Looper对象

2:必须调用Looper.loop()去消息队列中轮询消息,否则你发送消息,没有Looper处理消息.

4:消息回收

在Looper.loop()轮询的时候,方法最后一行代码:

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

最后一行代码可以看到msg调用了recycleUnchecked(),进入到这个方法

/**
 * Recycles a Message that may be in-use.
 * Used internally by the MessageQueue and Looper when disposing of queued Messages.
 */
void recycleUnchecked() {
    // Mark the message as in use while it remains in the recycled object pool.
    // Clear out all other details.
    flags = FLAG_IN_USE;
    what = 0;
    arg1 = 0;
    arg2 = 0;
    obj = null;
    replyTo = null;
    sendingUid = -1;
    when = 0;
    target = null;
    callback = null;
    data = null;

    synchronized (sPoolSync) {
        if (sPoolSize < MAX_POOL_SIZE) {
            next = sPool;
            sPool = this;
            sPoolSize++;
        }
    }
}

经历一系列的赋null操作,消息池中最大的消息数是50,

private static final int MAX_POOL_SIZE = 50;

5:很多框架的回调接口怎么让他在主线程中执行；

Handler handler = new Handler(Looper.getMainLooper());
handler.post(new Runnable() {
    @Override
    public void run() {
        //回调接口
    }
});