Aller au contenu
Hugo Delacour
Tous les articles

16 millisecondes : ce qui fige une page

Une page ne gèle pas parce que le JavaScript est lent, mais parce qu'il garde la main. Comment tourne la boucle d'événements, ce que coûte une tâche longue, et comment découper, déléguer ou animer sans bloquer l'image suivante.

4 novembre 20267 min
  • Performance
  • JavaScript
  • Navigateur
  • Web Vitals

Un clic, et rien ne se passe pendant un tiers de seconde. Le bouton ne s'enfonce pas, le curseur ne clignote plus, l'animation s'arrête net. Ce n'est pas que le JavaScript soit lent : c'est qu'il garde la main. Une page web n'a qu'un fil principal, et tant qu'une tâche l'occupe, rien d'autre n'y passe — ni la réponse au clic, ni l'image suivante.

À 60 Hz, l'écran attend une nouvelle image toutes les 16,7 ms ; à 120 Hz, toutes les 8,3 ms. C'est le budget, et tout ce qui le dépasse se voit.

Un tour de boucle

Le navigateur fait tourner une boucle, que décrit la norme HTML. À chaque tour :

  1. il prend une tâche dans une file — un clic, un minuteur, la réponse d'un fetch — et l'exécute jusqu'au bout ;
  2. il vide toutes les microtâches : les suites de promesses, queueMicrotask, les MutationObserver ;
  3. s'il est temps de peindre une image, il exécute les rappels de requestAnimationFrame, recalcule le style, la mise en page, et peint.
UN TOUR DE BOUCLEIMAGESUIVANTERENDU : SEULEMENT QUAND UNE IMAGE EST DUETâcheMicrotâchesrAFStyleMise en pagePeintureFILE DES TÂCHESclicsetTimeoutfetch
Un tour de boucle : une tâche, toutes les microtâches, puis, quand une image est due, les rappels de requestAnimationFrame (rAF), le style, la mise en page et la peinture.

Deux conséquences. Une tâche ne s'interrompt jamais : le JavaScript va jusqu'au bout de la fonction, quoi qu'il arrive à l'écran. Et le rendu ne passe qu'entre deux tâches : une tâche de 300 ms, ce sont 300 ms sans image.

Les microtâches ont une particularité : leur file est vidée entièrement, y compris des microtâches ajoutées pendant qu'on la vide. Une chaîne de promesses qui se relance sans fin ne rend jamais la main au rendu, et la page gèle — là où une chaîne de setTimeout laisserait passer les images.

// Gèle la page : la file des microtâches ne se vide jamais.
function geler() {
  Promise.resolve().then(geler);
}
 
// Ne gèle pas : chaque relance est une nouvelle tâche, le rendu passe entre deux.
function respirer() {
  setTimeout(respirer, 0);
}

Ce que coûte une tâche longue

Une tâche de plus de 50 ms est dite longue : c'est le seuil des outils de mesure, celui au-delà duquel une interaction commence à se sentir. Son coût n'est pas seulement le temps qu'elle prend, c'est tout ce qu'elle retient. Un clic arrivé pendant la tâche attend qu'elle finisse, puis sa réponse attend l'image suivante.

DEUX CENTS MILLISECONDES, UNE IMAGE TOUTES LES 16,7 MS0 ms50 ms100 ms150 ms200 msUn seul bloc130 MS D'AFFILÉEtâche longueclicréponse visible : 113 msDécoupéPAR 10 MSclicréponse visible : 13 ms
La même charge de travail, d'un seul bloc puis découpée. D'un bloc, sept images sont manquées et le clic n'est visible qu'au bout de 113 ms. Découpée, chaque image est peinte et le clic se voit en 13 ms.

C'est exactement ce que mesure l'INP (Interaction to Next Paint), l'indicateur de réactivité des Core Web Vitals : le temps entre une interaction et l'image qui en montre l'effet. Google le juge bon sous 200 ms, mauvais au-delà de 500. Une seule tâche de 130 ms en consomme plus de la moitié.

Le même travail, découpé, prend un peu plus longtemps au total : chaque reprise a un coût. Mais la page reste vivante. Chaque image est peinte, et le clic est servi entre deux morceaux.

Rendre la main

Découper un long travail, c'est lui faire rendre la main au navigateur à intervalles réguliers :

async function traiter(lignes: Ligne[]) {
  let depuis = performance.now();
  for (const ligne of lignes) {
    calculer(ligne);
    // Toutes les 10 ms, on laisse passer le rendu et les clics.
    if (performance.now() - depuis > 10) {
      await rendreLaMain();
      depuis = performance.now();
    }
  }
}
 
function rendreLaMain(): Promise<void> {
  // scheduler.yield() reprend en priorité, devant les tâches en attente.
  if ("scheduler" in globalThis && "yield" in scheduler) return scheduler.yield();
  return new Promise((resolve) => setTimeout(resolve, 0));
}

scheduler.yield() existe dans Chromium depuis 2024 ; ailleurs, le repli sur setTimeout fait l'affaire, avec une nuance : la suite repasse en fin de file, derrière les autres tâches. Et setTimeout(fn, 0) n'attend jamais vraiment zéro : après cinq relances imbriquées, la norme impose au moins 4 ms.

Pour toucher à l'affichage, le bon moment est requestAnimationFrame : son rappel s'exécute juste avant le style et la mise en page de l'image à venir. Une animation qui s'en sert peint au rythme de l'écran ; une animation menée par setTimeout(…, 16) dérive, tombe parfois entre deux images, et en peint deux d'un coup. Dans un onglet caché, requestAnimationFrame s'arrête — une animation n'a pas à tourner pour personne.

Sur ce site, une fourmi de Langton fait ainsi plus d'un million de pas par image : à chaque requestAnimationFrame, elle calcule douze millisecondes, puis rend la main. Le reste du budget sert à peindre.

Déléguer : les autres fils

Certains calculs ne se découpent pas, ou mal : une requête SQL, le décodage d'un fichier, un algorithme qui ne sait pas s'arrêter au milieu. Leur place est dans un Web Worker : un autre fil, sans accès au DOM, mais qui ne bloque jamais la page. On lui parle par messages.

// worker.ts
self.onmessage = (e: MessageEvent<string>) => {
  const resultat = executer(e.data); // des secondes, s'il le faut
  self.postMessage(resultat);
};
 
// La page
const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
worker.onmessage = (e) => afficher(e.data);
worker.postMessage("SELECT …");

Un avantage de plus : un worker qui s'éternise se tue avec worker.terminate(), ce qu'aucune fonction du fil principal ne permet. Une base SQLite compilée en WebAssembly peut ainsi exécuter une requête de dix secondes sans figer la page, et s'arrêter d'un clic.

Workercalcul longFil principalJS · style · layoutGPUpixels à l'écranCompositeurtransform · opacitypostMessagecalquesimages
Les fils d'une page : le fil principal pour le JavaScript, le style et la mise en page ; le compositeur pour assembler les calques ; un worker pour ce qui prend du temps.

Le navigateur a lui-même plusieurs fils. Le compositeur assemble les calques que le fil principal lui transmet, et les confie au GPU. Une animation CSS de transform ou d'opacity peut vivre entièrement chez lui : elle reste fluide pendant que le fil principal est bloqué. Une animation de left, de width ou de margin, elle, demande une mise en page à chaque image — sur le fil principal, donc à la merci de la prochaine tâche longue.

La mise en page forcée

Dernier piège, le plus discret. Le navigateur repousse la mise en page jusqu'au moment de peindre — sauf si le code la réclame avant. Lire offsetHeight, getBoundingClientRect() ou scrollTop juste après avoir modifié le DOM l'oblige à tout recalculer sur-le-champ. Dans une boucle, c'est une mise en page par tour :

// Une mise en page forcée par carte : chaque lecture suit l'écriture du tour précédent.
for (const carte of cartes) {
  carte.style.width = `${carte.offsetWidth + 10}px`;
}
 
// Une seule : toutes les lectures d'abord, toutes les écritures ensuite.
const largeurs = cartes.map((carte) => carte.offsetWidth);
cartes.forEach((carte, i) => (carte.style.width = `${largeurs[i] + 10}px`));

L'onglet Performance des outils de développement signale ces mises en page forcées, avec la ligne de code qui les a déclenchées.

Quand une page gèle

Symptôme Cause probable Remède
Le clic répond en retard une tâche longue découper, scheduler.yield()
La page gèle sans fin une chaîne de microtâches repasser par une tâche
Une animation saccade elle anime des propriétés de mise en page transform, opacity
Un calcul fige tout trop lourd pour être découpé un Web Worker
Une boucle sur le DOM rame des mises en page forcées lire d'abord, écrire ensuite

Pour trouver la tâche coupable, l'onglet Performance de Chrome dessine chaque tâche du fil principal et marque d'un triangle rouge celles qui dépassent 50 ms. En production, l'API Long Animation Frames dit quel script a retenu chaque image trop longue.

En résumé

  1. Un seul fil principal : tant qu'une tâche tourne, ni clic ni image.
  2. Une image toutes les 16,7 ms à 60 Hz ; une tâche est longue au-delà de 50 ms.
  3. Les microtâches passent toutes avant le rendu : une chaîne sans fin gèle la page.
  4. On découpe et on rend la main : scheduler.yield(), sinon setTimeout.
  5. Ce qui ne se découpe pas part dans un Web Worker.
  6. On anime transform et opacity, que le compositeur sait faire seul.
  7. On lit la mise en page avant d'écrire dans le DOM.