android之Handler详解

一，Handler实现每一秒打印一次

第一种实现

该实现是从1秒的开始进行计时

public class TimerThread extends Thread {
    private H mH;
    private int timerMills = 1000;

    @Override
    public void run() {
        super.run();
        Looper.prepare();
        mH = new H();
        mH.sendMessageDelayed(mH.obtainMessage(), timerMills);
        Looper.loop();
    }

    class H extends Handler {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            Log.e("TimerThread", "M---------------------------------");
            mH.sendMessageDelayed(mH.obtainMessage(), timerMills - System.currentTimeMillis() % timerMills);
        }
    }
    public void setTimerMills(int timerMills) {
        this.timerMills = timerMills;
    }

    public void quit() {
        Looper.myLooper().quit();
    }

}

代码打印如下，明显一

第二种实现

该方法是从一秒内随意位置进行计时打印

public class TimerThread extends Thread {
    private H mH;
    private int timerMills = 1000;
    private long oldTime;
    private long diffTime;

    @Override
    public void run() {
        super.run();
        Looper.prepare();
        mH = new H();
        oldTime = System.currentTimeMillis();
        mH.sendMessageDelayed(mH.obtainMessage(), timerMills);
        Looper.loop();
    }

    class H extends Handler {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            long newTime = System.currentTimeMillis();
            long diff = newTime - oldTime;
            oldTime = newTime;
            long startTIme;
            if (diff > timerMills) {
                diffTime += diff % timerMills;
            } else if (diff < timerMills) {
                diffTime += diff - timerMills;
            }
            startTIme = timerMills - diffTime;
            Log.e("TimerThread", "-------" + timerMills + "------" + diff + "-------" + diffTime + "-------" + startTIme + "------");
            mH.sendMessageDelayed(mH.obtainMessage(), startTIme);
        }
    }

    public void setTimerMills(int timerMills) {
        this.timerMills = timerMills;
    }

    public void quit() {
        Looper.myLooper().quit();
    }

}

打印如下

二，源码解析

Looper.prepare()

1，保存创建的Looper到ThreadLocal

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

2，创建MessageQueue，活动当前线程

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

Message创建，获取了一个native方法

 MessageQueue(boolean quitAllowed) {
        mQuitAllowed = quitAllowed;
        mPtr = nativeInit();
    }

2，Looper.loop()出队列

    public static void loop() {
        
        //获取当前线程
        final Looper me = myLooper();
        //进行死循环获取消息
        for (;;) {
            if (!loopOnce(me, ident, thresholdOverride)) {
                return;
            }
        }
    }

    private static boolean loopOnce(final Looper me,
            final long ident, final int thresholdOverride) {
        //从MessageQueuq中拿出Message
        Message msg = me.mQueue.next(); // might block
        //如果messagequeue中没有消息了，退出循环
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return false;
        }
        try {
            //拿出message中的Handler，执行它的ddispatchMessage;
            msg.target.dispatchMessage(msg);

        } catch (Exception exception) {
        } finally {
        }
        //message释放
        msg.recycleUnchecked();

        return true;
    }

1，MessageQueue.next()出队

    Message next() {
        // Return here if the message loop has already quit and been disposed.
        // This can happen if the application tries to restart a looper after quit
        // which is not supported.
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }
        

        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }

            //在没有消息的时候，会阻塞在这里，等待唤醒
            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                //头部消息赋值给msg
                Message msg = mMessages;
                //当前消息不为空并且消息的handler是空的
                if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg; 
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                //当前消息不为空
                if (msg != null) {
                    //当前实际小于msg的时间
                    if (now < msg.when) {
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        //计算这条消息在当前时间需要多久才执行
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        //正常执行该条消息秒，
                        // Got a message.
                        mBlocked = false;
                        //prevMsg.next等于下一条消息
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            //该消息等于消息队列的下一条消息
                            mMessages = msg.next;
                        }
                        //第一个消息从消息链表中断开
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // No more messages.
                    //消息队列没有消息了
                    nextPollTimeoutMillis = -1;
                }

                // Process the quit message now that all pending messages have been handled.
                //退出消息循环，退出loop循环
                if (mQuitting) {
                    dispose();
                    return null;
                }

                // If first time idle, then get the number of idlers to run.
                // Idle handles only run if the queue is empty or if the first message
                // in the queue (possibly a barrier) is due to be handled in the future.
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    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(TAG, "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;
        }
    }

2，Message.target.dispatchMessage(msg)执行消息回调

3,Hanler.dispatchMessage

对应方法是不是以为空，不为空就执行对应的数据

   public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            //初始化handler的时候创建
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            //如果没有创建，直接调用handler中的方法，该方法是一个空方法
            handleMessage(msg);
        }
    }

msg.callback

Message类中创建

  public static Message obtain(Handler h, Runnable callback) {
        Message m = obtain();
        m.target = h;
        m.callback = callback;

        return m;
    }

?

3，入队

1，Handler创建

   public Handler(@Nullable Callback callback, boolean async) {
        //获取消息队列
        mQueue = mLooper.mQueue;
        //获取传入的caollback
        mCallback = callback;
        mAsynchronous = async;
    }

2，Handler.sendMessage

Handler的所有senndMessage方法最总都会调用

  public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
        //创建handler的时候获取到队列
        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);
    }

3,Handler.enqueueMessage

    private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        //赋值message的handler，这里message会持有handler的对象，内存泄漏的最初位置
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

4，MessageQueue.queue.enqueueMessage(msg, uptimeMillis)

   boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        
        //加锁，放在反复加入
        synchronized (this) {
            if (msg.isInUse()) {
                throw new IllegalStateException(msg + " This message is already in use.");
            }

            //如果退出了，释放该message，退出
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w(TAG, e.getMessage(), e);
                msg.recycle();
                return false;
            }

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            //将message加入到第一个位置
            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;
                //循环遍历将传入的message放在对应时间点的位置
                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;
    }

这样handler的流程就走完了