Exemple d'analyse de code de barrière de synchronisation du gestionnaire Java

1. Dans le processus de chargement et de dessin de View, il y a une classe de chorégraphe, mChoreographer.

mTraversalBarrier = mHandler.getLooper().postSyncBarrier();Insérez un message de barrière de synchronisation dans la MessageQueue, msg.target==null message, la valeur de retour mTraversalBarrier est un valeur du jeton int. La méthode 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() exécutera le code dans mTraversalRunnable.

mHandler.getLooper().removeSyncBarrier(mTraversalBarrier);Cela supprimera le message de barrière de synchronisation dans MessageQueue en fonction de la valeur du jeton générée ci-dessus.

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

Regardons cette ligne de code mHandler.getLooper().postSyncBarrier() pour voir comment le système la gère.

Obtention d'un message sans gestionnaire.

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

Normalement, nous envoyons des messages via le gestionnaire, et le gestionnaire n'est pas autorisé à être vide.

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

Alors pourquoi le système envoie-t-il un message avec un gestionnaire vide ?

Voyons d'abord ce que mChoreographer a fait après avoir envoyé le message de barrière de synchronisation ?

Un autre message asynchrone a été envoyé : msg.setAsynchronous(true). Le gestionnaire de ce message n'est pas nul.

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

Ensuite, voyons comment MessageQueue envoie des messages et comment traiter ce message de barrière de synchronisation.

rrreee

Lors de l'annulation, jugez d'abord que msg.target est nul, puis parcourez la boucle while pour trouver le message selon lequel msg.isAsynchronous() == true. C'est le message asynchrone envoyé ci-dessus. Habituellement, les messages que nous envoyons sont des messages synchrones et msg.setAsynchronous(true);

Le but du système est de traiter en premier ce message asynchrone. Tous les messages de synchronisation seront placés à l'arrière, tout comme une barrière, donc une telle opération est appelée barrière de synchronisation, et le traitement des messages de barrière de synchronisation a une priorité plus élevée. #🎜🎜##🎜🎜#Étant donné que la classe de chorégraphe mChoreographer est responsable du rendu de l'écran, elle doit traiter les signaux de la couche inférieure en temps opportun pour garantir la fréquence de rafraîchissement de l'interface. #🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!