Blog

Ich habe React-Native-Listen 8000x schneller gemacht

20. Juni 2026 9 Min. Lesezeit

Wie mein gemergter React-Native-PR die Render-Window-Arbeit von FlatList und VirtualizedList um bis zu 8000x schneller gemacht hat.

Ich habe React-Native-Listen 8000x schneller gemacht
React NativeFlatListVirtualizedListPerformanceOpen Source

Ja, du hast richtig gelesen: 8000x schneller.

Nicht im Sinne von "deine ganze App ist jetzt 8000x schneller, kauf dir eine Yacht". Leider.

Und ja, ich weiß, das Timing ist lustig.

Wir leben in einer Zeit, in der KI-News so schnell kommen, dass so etwas wie Claude Fable 5 erscheinen und ein paar Tage später wieder ausgesetzt werden kann. Die Leute streiten über fast AGI-artige Modelle, Exportkontrollen, Agents, die ganze Projekte umsetzen, und so weiter.

Und ich sitze hier und rede darüber, wie man Listen in React Native schneller macht.

Wenn man beides nebeneinanderstellt, klingt das etwas seltsam. Verstehe ich.

Trotzdem finde ich diese Art von Arbeit spannend. Vielleicht ist "Erfindung" ein zu großes Wort, aber ein Framework zu verbessern, das Tausende Apps nutzen, fühlt sich für mich trotzdem bedeutsam an. Nicht alles Nützliche muss wie Science-Fiction aussehen. Manchmal geht es einfach darum, verschwendete Arbeit aus einem Pfad zu entfernen, den fast jede mobile App durchläuft.

Der Gewinn steckt in einem ganz bestimmten Listen-Pfad von React Native: der Render-Window-Arbeit, die entscheidet, welche Zellen gerade existieren sollen. In diesem Benchmark konnte der alte Pfad bei riesigen Listen Sekunden verschwenden, und der neue Pfad drückt das auf wenige Millisekunden.

Meistens sind wir auf der App-Seite. Wir nutzen FlatList, SectionList, Navigation, Animationen, State-Libraries und den ganzen üblichen Kram. Wir beschweren uns über die Performance, probieren ein paar Props aus, fügen memo hinzu, vielleicht noch getItemLayout, und machen dann mit unserem Leben weiter.

Aber manchmal liegt das eigentliche Problem eine Ebene unter dem App-Code.

Genau das ist hier passiert.

Ich habe eine Performance-Verbesserung zu react/react-native beigetragen, gemergt als PR #57210. Die Änderung entfernt unnötige Suchen nach Sticky Headern aus dem Pfad, in dem VirtualizedList die Render Mask erstellt.

GitHub-Timeline, die zeigt, wie der Pull Request zur FlatList-Performance in React Native gemergt wurde
In React Native gemergt. Fühlt sich immer noch ein bisschen unwirklich an.

In normalen Worten: React Native hat manchmal nach Sticky Headern gesucht, obwohl die Liste gar keine Sticky Header hatte.

Klassischer Computer-Moment.

Liste: "Ich habe keine Sticky Header."

React Native: "Cool, dann suche ich mal rückwärts nach einem."

Das Schöne ist, dass dieser Pfad gemeinsam genutzt wird. Die Verbesserung betrifft also:

  • VirtualizedList
  • FlatList
  • VirtualizedSectionList
  • SectionList

Und ja, auch eine ganz normale FlatList kann davon profitieren, selbst wenn du überhaupt keine Sticky Header verwendest.

Was das tatsächlich verbessert

Bevor wir in den Code gehen, lohnt es sich zu sagen, um welche Art von Performance es hier geht.

Die Verbesserung betrifft die JavaScript-Arbeit, die React Native erledigt, bevor es entscheidet, welche Zeilen gerendert werden sollen.

FlatList hält ein Render Window. Während du scrollst, springst, in der Nähe eines initialen Index mountest oder dich durch eine große Liste bewegst, muss React Native entscheiden, welche Zellen gerendert werden und welche Teile als Spacer bleiben können.

Diese Entscheidung läuft über VirtualizedList._createRenderMask.

Der Gewinn ist also:

  • weniger JS-Arbeit bei Updates des Listen-Windows
  • weniger Arbeit beim Springen ans Ende einer riesigen Liste
  • weniger unnötige Sticky-Header-Logik bei Listen ohne Sticky Header
  • schnellere Entscheidungen, bevor die Liste aktualisiert, was auf dem Screen sein soll

In App-Begriffen hilft das dem Teil von FlatList, der entscheidet: "Welche Zeilen sollen gerade existieren?"

Bei sehr großen Listen, besonders in der Nähe des Listenendes, kann diese kleine interne Entscheidung zu echten Kosten werden.

Wenn man diese Kosten entfernt, wird der Update-Pfad des Render Windows viel günstiger.

Was mir aufgefallen ist

FlatList ist eine dieser Komponenten, die fast jede React-Native-App irgendwann nutzt.

Von außen sieht sie einfach aus:

<FlatList data={items} renderItem={renderItem} />

Aber unter der Haube läuft sie über VirtualizedList.

VirtualizedList rendert nicht die gesamte Datenquelle. Wenn du 100k Zeilen hast, packt sie nicht 100k Zeilen auf den Screen wie ein tapferer, aber verlorener Soldat. Sie hält ein Render Window und nutzt eine Render Mask, um zu entscheiden, welche Zellen gerade existieren sollen.

Das ist gut.

Das Problem lag im Schritt, in dem die Render Mask erstellt wird.

React Native unterstützt auch Sticky Header. Sticky Header sind besonders, weil das Sticky-Element außerhalb des normalen Viewports liegen kann, aber trotzdem gerendert bleiben muss, weil es optisch oben festklebt.

React Native braucht also Logik wie:

"Finde den nächstgelegenen Sticky Header vor dem Viewport und halte ihn gerendert."

Diese Logik ist korrekt.

Das Ärgerliche war, dass die Suche trotzdem laufen konnte, wenn es gar keine Sticky Header gab.

Der alte Pfad

Vor dieser Änderung hat VirtualizedList._createRenderMask aus stickyHeaderIndices ein Set gebaut und den Sticky-Header-Helper aufgerufen.

Vereinfacht sah das so aus:

const stickyIndicesSet = new Set(props.stickyHeaderIndices);
VirtualizedList._ensureClosestStickyHeader(
  props,
  stickyIndicesSet,
  renderMask,
  cellsAroundViewport.first,
);

Dann ist der Helper ab der ersten sichtbaren Zelle rückwärts gelaufen:

for (let itemIdx = cellIdx - 1; itemIdx >= 0; itemIdx--) {
  if (stickyIndicesSet.has(itemIdx + stickyOffset)) {
    renderMask.addCells({first: itemIdx, last: itemIdx});
    break;
  }
}

Bei einer kleinen Liste ist das egal.

Bei einer sehr großen Liste wird es schmerzhaft. Wenn der Viewport nahe am Ende einer Liste mit 1 Million Zeilen ist und es keine Sticky Header gibt, kann der Helper trotzdem fast die gesamte Liste rückwärts durchlaufen.

Das ist im Grunde eine große Suche, um nichts zu finden.

Nicht gerade mein Lieblingshobby.

Warum FlatList betroffen ist

Dieser Teil wird leicht übersehen.

Du musst VirtualizedList nicht direkt verwenden. FlatList baut darauf auf.

Also läuft auch diese Art von Code:

<FlatList
  data={bigData}
  renderItem={renderItem}
/>

weiterhin über VirtualizedList._createRenderMask.

Vor der Änderung konnte eine normale Liste ohne stickyHeaderIndices trotzdem für die Sticky-Header-Suche bezahlen.

Nach der Änderung prüft React Native, ob es überhaupt Sticky Header gibt, bevor es Sticky-Header-Arbeit erledigt.

Hochmoderne Technologie: erst prüfen, ob es das Ding gibt, bevor man danach sucht.

Die Änderung

Der erste Teil ist der wichtige für die normale FlatList ohne Sticky Header.

const stickyHeaderIndices = props.stickyHeaderIndices;
if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
  VirtualizedList._ensureClosestStickyHeader(
    props,
    stickyHeaderIndices,
    renderMask,
    cellsAroundViewport.first,
  );
}

Wenn es keine Sticky Header gibt, überspringen wir den Helper.

Der zweite Teil verbessert auch den Fall mit Sticky Headern.

Statt rückwärts durch die Item-Indizes zu laufen, durchsucht der Helper die konfigurierten Sticky-Header-Indizes und findet den nächstgelegenen gültigen Sticky Header vor dem Viewport.

const stickyOffset = props.ListHeaderComponent ? 1 : 0;
const targetStickyIndex = cellIdx + stickyOffset;
let closestStickyIndex = null;

for (let itemIdx = 0; itemIdx < stickyHeaderIndices.length; itemIdx++) {
  const stickyIndex = stickyHeaderIndices[itemIdx];
  if (
    Number.isInteger(stickyIndex) &&
    stickyIndex < targetStickyIndex &&
    stickyIndex >= stickyOffset &&
    (closestStickyIndex == null || stickyIndex > closestStickyIndex)
  ) {
    closestStickyIndex = stickyIndex;
  }
}

if (closestStickyIndex != null) {
  const itemIdx = closestStickyIndex - stickyOffset;
  renderMask.addCells({first: itemIdx, last: itemIdx});
}

Die Kosten ändern sich also von:

"Wie weit sind wir vom Anfang der Liste entfernt?"

zu:

"Wie viele Sticky Header sind konfiguriert?"

Das ist eine viel bessere Frage.

Das Verhalten gleich halten

Das ist der Teil, der kleine Framework-Änderungen weniger klein macht, als sie aussehen.

Man kann nicht einfach optimieren und hoffen, dass alles passt. stickyHeaderIndices kann unsortiert sein. Es kann doppelte Werte enthalten. Es kann ungültige Werte enthalten. Es kann eine ListHeaderComponent geben, die den Index um eins verschiebt.

All das muss weiterhin funktionieren.

Die Tests decken Fälle ab wie:

  • keine stickyHeaderIndices
  • leere stickyHeaderIndices
  • unsortierte Sticky-Indizes
  • doppelte Sticky-Indizes
  • negative Werte
  • Dezimalwerte
  • Werte nach dem Viewport
  • Behandlung des Offsets durch ListHeaderComponent

Der letzte Punkt ist wichtig. Sticky-Header-Indizes basieren auf den Child-Indizes der darunterliegenden ScrollView. Wenn es einen List Header gibt, ist Item-Index 0 nicht mehr Child-Index 0.

Kleine Off-by-one-Bugs lieben diese Ecke. Sie wohnen dort mietfrei.

Benchmark-Ergebnisse

Ich habe den Pfad VirtualizedList._createRenderMask direkt mit Fantom Hermes gebenchmarkt, mit 100 Samples pro Fall.

Dieser Benchmark konzentriert sich auf die Render-Window-Entscheidung innerhalb von VirtualizedList.

Also nein, das heißt nicht, dass jede FlatList in jeder App plötzlich 8000x schneller scrollt. Ich wünschte es. Ich wäre längst unerträglich deswegen.

Es heißt, dass dieser spezielle interne Windowing-Pfad für Listen massiv günstiger geworden ist. Und wenn der Benchmark von Sekunden verschwendeter Arbeit auf wenige Millisekunden fällt, ist das trotzdem ein sehr realer Gewinn.

Beweis im Simulator

Ich habe außerdem eine kleine Bare-React-Native-App gebaut, um beide Implementierungen im iOS-Simulator zu vergleichen.

Gleiche App. Gleiche FlatList mit 1m Zeilen. Gleiches Setup mit no sticky headers.

Der einzige Unterschied ist die installierte Implementierung von VirtualizedList. Das sind echte Simulator-Aufnahmen in den Handy-Rahmen, keine statischen Mockup-Screenshots. Die Video-Controls habe ich absichtlich sichtbar gelassen, und der pulsierende Cursor markiert den Tap auf den Benchmark-Button.

Der Benchmark und die Verhaltenstests sind auch im gemergten React-Native-PR enthalten:

Vorher
▶ Simulator-Video
Nachher
▶ Simulator-Video

In der Simulator-Demo wächst der alte Pfad mit der Listengröße. Für 1k Updates des Render Windows sieht das so aus:

  • 50k rows: insgesamt etwa 1.92 s (1.9196 ms / call)
  • 500k rows: insgesamt etwa 18.78 s (18.78 ms / call)
  • 1m rows: insgesamt etwa 38.40 s (38.40 ms / call)

Mit dem optimierten Pfad bleibt dieselbe Demo praktisch flach:

  • 50k rows: insgesamt etwa 3.74 ms (0.0037 ms / call)
  • 500k rows: insgesamt etwa 3.67 ms (0.0037 ms / call)
  • 1m rows: insgesamt etwa 3.73 ms (0.0037 ms / call)

Die Werte pro Aufruf liegen unter einer Sekunde und werden daher in Millisekunden angezeigt. Bei 1.000 Render-Mask-Updates werden Werte über einer Sekunde in Sekunden angezeigt.

FallEin Update vorherEin Update nachherSpeedup1.000 Updates vorher1.000 Updates nachher
100k Zeilen, keine Sticky Header2.664 ms0.0034 ms780x2.66 s3.42 ms
100k Zeilen, leere Sticky Header2.632 ms0.0033 ms800x2.63 s3.29 ms
100k Zeilen, ein Sticky Header oben2.705 ms0.0054 ms499x2.71 s5.42 ms
250k Zeilen, keine Sticky Header6.543 ms0.0035 ms1,892x6.54 s3.46 ms
250k Zeilen, leere Sticky Header6.579 ms0.0033 ms2,024x6.58 s3.25 ms
250k Zeilen, ein Sticky Header oben6.796 ms0.0053 ms1,294x6.80 s5.25 ms
500k Zeilen, keine Sticky Header13.173 ms0.0033 ms4,002x13.17 s3.29 ms
500k Zeilen, leere Sticky Header13.073 ms0.0033 ms3,997x13.07 s3.27 ms
500k Zeilen, ein Sticky Header oben13.444 ms0.0054 ms2,511x13.44 s5.35 ms
750k Zeilen, keine Sticky Header19.524 ms0.0033 ms6,008x19.52 s3.25 ms
750k Zeilen, leere Sticky Header19.572 ms0.0033 ms6,022x19.57 s3.25 ms
750k Zeilen, ein Sticky Header oben20.304 ms0.0054 ms3,778x20.30 s5.37 ms
1m Zeilen, keine Sticky Header26.190 ms0.0033 ms8,058x26.19 s3.25 ms
1m Zeilen, leere Sticky Header26.039 ms0.0033 ms8,012x26.04 s3.25 ms
1m Zeilen, ein Sticky Header oben26.855 ms0.0053 ms5,075x26.86 s5.29 ms

Die Spalte mit 1.000 Updates macht den Unterschied besser spürbar.

Bei 1 Million Zeilen verbringt der alte Pfad ohne Sticky Header etwa 26 Sekunden in diesem Helper für 1.000 Render-Mask-Updates.

Nach der Änderung liegt derselbe Fall bei etwa 3.25 ms.

Das ist Zeit, die aus einem gemeinsam genutzten Listen-Pfad verschwindet, bevor React Native entscheidet, welche Zellen gerendert werden sollen.

Testplan

Ich wollte, dass das im besten Sinne langweilig ist: gleiches Verhalten, weniger Arbeit.

Deshalb enthielt der Beitrag Verhaltenstests und Benchmark-Abdeckung.

Die wichtigsten Befehle waren:

yarn jest packages/virtualized-lists/Lists/__tests__/VirtualizedList-test.js packages/virtualized-lists/Lists/__tests__/VirtualizedSectionList-test.js packages/react-native/Libraries/Lists/__tests__/FlatList-test.js --runInBand
yarn fantom packages/react-native/Libraries/Lists/__tests__/FlatList-itest.js packages/react-native/Libraries/Lists/__tests__/SectionList-itest.js --runInBand
yarn flow check
yarn fantom --benchmarks packages/react-native/Libraries/Lists/__tests__/VirtualizedList-stickyHeaders-benchmark-itest.js --runInBand

Der PR hat drei Dateien geändert:

  • die Implementierung von VirtualizedList
  • gezielte Tests für VirtualizedList
  • einen Fantom-Benchmark für den Render-Mask-Pfad mit Sticky Headern

Er wurde über den Prozess von Meta importiert und in react/react-native gemergt.

Fazit

Was mir an diesem Beitrag gefällt: App-Entwickler müssen nichts tun.

Kein neues Prop.

Keine Migration.

Kein Workaround.

Wenn eine App eine große FlatList ohne Sticky Header nutzt, kann React Native jetzt die Sticky-Header-Suche vermeiden, die von vornherein unnötig war.

Das ist meine Lieblingsart von Framework-Verbesserung.

Kleine Angriffsfläche. Klarer Benchmark. Keine API-Änderung.

Und ein häufig genutzter Pfad wird für alle günstiger.