Beispielcode-Analyse für die Java-Handler-Synchronisationsbarriere

1. Im Lade- und Zeichenprozess von View gibt es eine Choreografenklasse, mChoreographer.

mTraversalBarrier = mHandler.getLooper().postSyncBarrier(); Fügen Sie eine Synchronisationsbarriere-Nachricht in die MessageQueue ein, msg.target==null-Nachricht, der Rückgabewert mTraversalBarrier ist ein int-Token-Wert. Die Methode mTraversalBarrier = mHandler.getLooper().postSyncBarrier();向MessageQueue中插入一条同步屏障消息，msg.target==null的消息，返回值mTraversalBarrier是一个int 的token值。

  void scheduleTraversals() {
    if (!mTraversalScheduled) {
      mTraversalScheduled = true;
       //向消息队列插入一个同步屏障的消息。msg.target==null的消息
             mTraversalBarrier = mHandler.getLooper().postSyncBarrier();
             mChoreographer.postCallback(
                  Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
    }
  }

mChoreographer.postCallback（）方法会执行mTraversalRunnable中的代码。

mHandler.getLooper().removeSyncBarrier(mTraversalBarrier);

 final TraversalRunnable mTraversalRunnable = new TraversalRunnable();
 final class TraversalRunnable implements Runnable {
            @Override
            public void run() {
                doTraversal();
            }
  }
   void doTraversal() {
      if (mTraversalScheduled) {
          mTraversalScheduled = false;
          //移除同步屏障消息
          mHandler.getLooper().removeSyncBarrier(mTraversalBarrier);
          //在这个方法中会调用 measure layout draw，view的绘制绘制流程的方法
          performTraversals();
      }
    }

mChoreographer.postCallback() führt den Code in mTraversalRunnable aus.

mHandler.getLooper().removeSyncBarrier(mTraversalBarrier);Dadurch wird die Synchronisationsbarrierennachricht in der MessageQueue basierend auf dem oben generierten Tokenwert entfernt.

int enqueueSyncBarrier(long when) {
        // Enqueue a new sync barrier token.
        // We don't need to wake the queue because the purpose of a barrier is to stall it.
        synchronized (this) {
            final int token = mNextBarrierToken++;
            // 这个msg.target没有被赋值
            final Message msg = Message.obtain();
            msg.markInUse();
            msg.when = when;
            msg.arg1 = token;
            Message prev = null;
            Message p = mMessages;
            if (when != 0) {
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
            }
            if (prev != null) { // invariant: p == prev.next
                msg.next = p;
                prev.next = msg;
            } else {
                msg.next = p;
                mMessages = msg;
            }
            return token;
        }
    }

Schauen Sie sich diese Codezeile mHandler.getLooper().postSyncBarrier() an, um zu sehen, wie das System damit umgeht.

Eine Nachricht erhalten, ohne dass ein Handler festgelegt wurde.

 boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
   ...........
}

Normalerweise senden wir Nachrichten über den Handler, und der Handler darf nicht leer sein.

private void postCallbackDelayedInternal(int callbackType,
            Object action, Object token, long delayMillis) {
      synchronized (mLock) {
            final long now = SystemClock.uptimeMillis();
            final long dueTime = now + delayMillis;
            mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);
            if (dueTime <= now) {
                scheduleFrameLocked(now);
            } else {
                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);
                msg.arg1 = callbackType;
                //将消息设置为异步消息
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, dueTime);
            }
        }
}

Warum sendet das System dann eine Nachricht mit einem leeren Handler?

Sehen wir uns zunächst an, was mChoreographer nach dem Senden der Synchronisierungsbarriere-Nachricht getan hat.

Eine weitere asynchrone Nachricht wird gesendet: msg.setAsynchronous(true). Der Handler dieser Nachricht ist nicht null.

 Message next() {
            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                //如果msg.target==null说明我们已经向消息队里中插入了一条屏障消息。
                //此时会进入到这个循环中，找到msg.isAsynchronous==true的异步消息。
                //通常我们发送的都是同步消息isAsynchronous = false的，并且msg.target不能为null的。
                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());//msg.isAsynchronous==true时结束循环，说明找到了这个异步消息。
                }
                if (msg != null) {//找到了同步屏障的异步消息后，直接返回
                    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;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (false) Log.v("MessageQueue", "Returning message: " + msg);
                        return msg;
                    }
                } else {//没有找到的话则进入休眠直到下一次被唤醒
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
        }
    }

Schauen wir uns als Nächstes an, wie MessageQueue Nachrichten sendet und wie es mit dieser Synchronisierungsbarriere-Nachricht umgeht.

rrreee

Beurteilen Sie beim Abbrechen zunächst, ob msg.target null ist, und durchlaufen Sie dann die while-Schleife, um die Meldung zu finden, dass msg.isAsynchronous() == true ist. Das ist die oben gesendete asynchrone Nachricht. Normalerweise sind die von uns gesendeten Nachrichten synchrone Nachrichten und msg.setAsynchronous(true); wird nicht festgelegt.

Der Zweck des Systems besteht darin, diese asynchrone Nachricht zuerst zu verarbeiten. Alle Synchronisationsnachrichten werden wie eine Barriere hinten platziert. Daher wird ein solcher Vorgang als Synchronisationsbarriere bezeichnet und die Verarbeitung von Synchronisationsbarrierenachrichten hat eine höhere Priorität. 🎜🎜Da die Choreografenklasse mChoreographer für die Bildschirmwiedergabe verantwortlich ist, muss sie die Signale der unteren Ebene rechtzeitig verarbeiten, um die Häufigkeit der Schnittstellenaktualisierung sicherzustellen. 🎜

Das obige ist der detaillierte Inhalt vonBeispielcode-Analyse für die Java-Handler-Synchronisationsbarriere. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!