# React 19 Suspense und Concurrent Rendering: Streaming SSR und Interview-Fragen 2026

> Umfassender Leitfaden zu React 19 Suspense, Concurrent Rendering und Streaming SSR. Enthält praktische Codebeispiele und häufige Interview-Fragen für 2026.

- Published: 2026-08-21
- Updated: 2026-08-21
- Author: Anthony Fillion-Maillet
- Reading time: 5 min

---

React 19 hat die Art und Weise, wie moderne Webanwendungen gebaut werden, grundlegend verändert. Mit der stabilen Veröffentlichung von Suspense für Data Fetching und den Verbesserungen im Concurrent Rendering können Entwickler nun reaktive Benutzeroberflächen erstellen, die schneller laden und flüssiger reagieren. Streaming SSR ermöglicht es, HTML-Fragmente progressiv an den Browser zu senden, noch bevor alle Daten verfügbar sind. Dieser Artikel behandelt die Kernkonzepte, praktische Implementierungen und die häufigsten Interview-Fragen zu diesen Themen im Jahr 2026.

> **Suspense ist mehr als nur ein Loading-Indikator**
>
> Während viele Entwickler Suspense nur als Wrapper für Fallback-UIs kennen, liegt seine wahre Stärke in der Koordination von asynchronen Operationen. React kann damit priorisieren, welche Teile der UI zuerst gerendert werden sollen, und ermöglicht so eine optimale User Experience selbst bei langsamen Netzwerkverbindungen. In Kombination mit Server Components wird Suspense zum zentralen Baustein moderner React-Architekturen.

## Grundlagen von React Suspense in Version 19

Suspense ermöglicht es React-Komponenten, auf asynchrone Operationen zu "warten", ohne komplexe State-Management-Logik zu implementieren. Das Konzept basiert auf dem Prinzip, dass Komponenten während des Ladens eine Promise "werfen" können, die React abfängt und einen Fallback anzeigt.

Die grundlegende Verwendung von Suspense hat sich seit React 18 stabilisiert, aber React 19 bringt wichtige Verbesserungen. Die Integration mit Server Components ist nun nahtlos, und die neue `use`-Hook ermöglicht direktes Promise-Handling innerhalb von Komponenten.

```tsx
import { Suspense, use } from 'react';

interface User {
  id: string;
  name: string;
  email: string;
}

function UserProfile({ userPromise }: { userPromise: Promise<User> }) {
  const user = use(userPromise);
  
  return (
    <div className="p-4 border rounded-lg">
      <h2 className="text-xl font-bold">{user.name}</h2>
      <p className="text-gray-600">{user.email}</p>
    </div>
  );
}

function UserProfileSkeleton() {
  return (
    <div className="p-4 border rounded-lg animate-pulse">
      <div className="h-6 bg-gray-200 rounded w-32 mb-2" />
      <div className="h-4 bg-gray-200 rounded w-48" />
    </div>
  );
}

export default function ProfilePage() {
  const userPromise = fetchUser('123');
  
  return (
    <Suspense fallback={<UserProfileSkeleton />}>
      <UserProfile userPromise={userPromise} />
    </Suspense>
  );
}
```

Der entscheidende Unterschied zu herkömmlichem State-basiertem Data Fetching liegt in der Deklarativität. Die Komponente beschreibt nur, was sie benötigt, nicht wie die Daten geladen werden sollen. React übernimmt die Koordination des Ladevorgangs.

## Concurrent Rendering und seine Auswirkungen

Concurrent Rendering ist keine einzelne Feature, sondern ein fundamentaler Wandel in der Art, wie React Rendering-Arbeit priorisiert und unterbricht. Traditionell blockierte ein Rendering-Vorgang den Main Thread, bis er abgeschlossen war. Mit Concurrent Rendering kann React Rendering-Arbeit pausieren, um dringendere Updates wie Benutzerinteraktionen zu verarbeiten.

Die praktischen Auswirkungen zeigen sich besonders bei komplexen UIs. Wenn ein Benutzer während eines aufwändigen Rendervorgangs tippt, kann React die Tastatureingabe priorisieren und das ursprüngliche Rendering später fortsetzen.

```tsx
import { useState, useTransition, useDeferredValue } from 'react';

function SearchResults({ query }: { query: string }) {
  // Expensive computation or data fetching
  const results = searchDatabase(query);
  
  return (
    <ul className="space-y-2">
      {results.map(result => (
        <li key={result.id} className="p-2 hover:bg-gray-100">
          {result.title}
        </li>
      ))}
    </ul>
  );
}

export function SearchPage() {
  const [query, setQuery] = useState('');
  const [isPending, startTransition] = useTransition();
  const deferredQuery = useDeferredValue(query);
  
  const handleSearch = (e: React.ChangeEvent<HTMLInputElement>) => {
    const value = e.target.value;
    setQuery(value); // Immediate update for input
    
    startTransition(() => {
      // Deferred update for expensive rendering
    });
  };
  
  return (
    <div className="p-4">
      <input
        type="text"
        value={query}
        onChange={handleSearch}
        placeholder="Suchen..."
        className="w-full p-2 border rounded"
      />
      
      <div className={isPending ? 'opacity-50' : ''}>
        <Suspense fallback={<div>Lädt Ergebnisse...</div>}>
          <SearchResults query={deferredQuery} />
        </Suspense>
      </div>
    </div>
  );
}
```

Die Kombination von `useTransition` und `useDeferredValue` ermöglicht eine feinkörnige Kontrolle über Rendering-Prioritäten. `useTransition` markiert State-Updates als nicht-dringend, während `useDeferredValue` einen verzögerten Wert liefert, der bei hoher Auslastung hinterherhinkt.

## Streaming SSR mit React Server Components

Streaming SSR revolutioniert die Server-seitige Renderingzeit. Anstatt auf alle Daten zu warten und dann eine vollständige HTML-Seite zu senden, beginnt React sofort mit dem Streaming von HTML-Fragmenten. Sobald ein Suspense-Boundary aufgelöst wird, sendet der Server das entsprechende HTML nach.

In Next.js 16 mit App Router ist Streaming SSR standardmäßig aktiviert. Jede Server Component, die in einem Suspense-Boundary eingeschlossen ist, wird automatisch gestreamt.

```tsx
// app/dashboard/page.tsx
import { Suspense } from 'react';

async function RevenueChart() {
  const data = await fetchRevenueData(); // 2 Sekunden
  
  return (
    <div className="bg-white p-6 rounded-lg shadow">
      <h3 className="font-semibold mb-4">Umsatz</h3>
      <Chart data={data} />
    </div>
  );
}

async function RecentOrders() {
  const orders = await fetchRecentOrders(); // 500ms
  
  return (
    <div className="bg-white p-6 rounded-lg shadow">
      <h3 className="font-semibold mb-4">Letzte Bestellungen</h3>
      <OrderList orders={orders} />
    </div>
  );
}

export default function DashboardPage() {
  return (
    <div className="grid grid-cols-2 gap-6 p-6">
      <Suspense fallback={<ChartSkeleton />}>
        <RevenueChart />
      </Suspense>
      
      <Suspense fallback={<OrdersSkeleton />}>
        <RecentOrders />
      </Suspense>
    </div>
  );
}
```

Der Browser empfängt zuerst das Layout-HTML mit beiden Skeletons. Sobald `RecentOrders` bereit ist (nach 500ms), streamt der Server das HTML und ein Script, das den Skeleton ersetzt. `RevenueChart` folgt nach 2 Sekunden. Der Time To First Byte (TTFB) verbessert sich dramatisch, da der Server sofort mit dem Senden beginnt.

## Fehlerbehandlung mit Error Boundaries

Suspense und Error Boundaries arbeiten zusammen, um sowohl Lade- als auch Fehlerzustände deklarativ zu handhaben. In React 19 können Error Boundaries auch asynchrone Fehler abfangen, die während des Server-Renderings auftreten.

```tsx
'use client';

import { Component, ReactNode } from 'react';

interface Props {
  children: ReactNode;
  fallback: ReactNode;
}

interface State {
  hasError: boolean;
  error: Error | null;
}

export class AsyncErrorBoundary extends Component<Props, State> {
  constructor(props: Props) {
    super(props);
    this.state = { hasError: false, error: null };
  }

  static getDerivedStateFromError(error: Error): State {
    return { hasError: true, error };
  }

  render() {
    if (this.state.hasError) {
      return this.props.fallback;
    }
    return this.props.children;
  }
}

// Verwendung mit Suspense
function DataSection() {
  return (
    <AsyncErrorBoundary
      fallback={
        <div className="p-4 bg-red-50 border border-red-200 rounded">
          <p className="text-red-700">Fehler beim Laden der Daten</p>
          <button
            onClick={() => window.location.reload()}
            className="mt-2 text-red-600 underline"
          >
            Erneut versuchen
          </button>
        </div>
      }
    >
      <Suspense fallback={<DataSkeleton />}>
        <AsyncDataComponent />
      </Suspense>
    </AsyncErrorBoundary>
  );
}
```

Die Hierarchie ist wichtig: Error Boundaries sollten Suspense-Boundaries umschließen, damit Fehler beim Data Fetching korrekt abgefangen werden. Andernfalls könnte ein Fehler die gesamte Seite zum Absturz bringen.

## Optimierungsmuster für Production

In Produktionsumgebungen erfordern Suspense und Streaming SSR sorgfältige Optimierung. Zu viele Suspense-Boundaries können zu einem "Popcorn-Effekt" führen, bei dem Inhalte unkoordiniert einblenden. Zu wenige bedeuten längere Wartezeiten.

```tsx
// Optimierte Struktur mit strategischen Boundaries
export default function ProductPage({ productId }: { productId: string }) {
  return (
    <div className="container mx-auto">
      {/* Kritischer Content - wird sofort gestreamt */}
      <Suspense fallback={<ProductHeaderSkeleton />}>
        <ProductHeader productId={productId} />
      </Suspense>
      
      {/* Sekundärer Content - gruppiert in einem Boundary */}
      <Suspense fallback={<ProductDetailsSkeleton />}>
        <ProductDescription productId={productId} />
        <ProductSpecifications productId={productId} />
        <ProductPricing productId={productId} />
      </Suspense>
      
      {/* Tertiärer Content - kann verzögert laden */}
      <Suspense fallback={<ReviewsSkeleton />}>
        <ProductReviews productId={productId} />
      </Suspense>
    </div>
  );
}
```

Prefetching spielt eine kritische Rolle bei der Performance. Mit React Server Components können Daten bereits geladen werden, bevor der Benutzer navigiert.

```tsx
import { prefetch } from 'react-router';
import Link from 'next/link';

function ProductCard({ product }: { product: Product }) {
  const handleMouseEnter = () => {
    // Prefetch beim Hover
    prefetch(`/products/${product.id}`);
  };

  return (
    <Link
      href={`/products/${product.id}`}
      onMouseEnter={handleMouseEnter}
      className="block p-4 border rounded hover:shadow-lg transition"
    >
      <img src={product.image} alt={product.name} />
      <h3>{product.name}</h3>
      <p>{product.price}</p>
    </Link>
  );
}
```

## Häufige Interview-Fragen zu Suspense und Concurrent Rendering

Technische Interviews im Jahr 2026 prüfen regelmäßig das Verständnis dieser Konzepte. Hier sind die wichtigsten Fragen und Antworten.

**Frage: Was ist der Unterschied zwischen useTransition und useDeferredValue?**

`useTransition` wird verwendet, um State-Updates als nicht-dringend zu markieren. Es gibt ein `isPending`-Flag zurück und eine `startTransition`-Funktion. `useDeferredValue` hingegen nimmt einen Wert entgegen und gibt eine verzögerte Version zurück, die bei hoher Rendering-Last hinterherhinken kann. `useTransition` ist für eigene State-Updates, `useDeferredValue` für Props oder Werte von außen.

**Frage: Wie funktioniert Streaming SSR technisch?**

Streaming SSR nutzt HTTP Transfer-Encoding: chunked. Der Server sendet zuerst das HTML-Gerüst mit Suspense-Fallbacks. Wenn eine Komponente bereit ist, sendet der Server ein HTML-Fragment zusammen mit einem inline `<script>`-Tag, das den Platzhalter im DOM ersetzt. Der Browser verarbeitet diese Chunks progressiv.

**Frage: Wann sollte Suspense vermieden werden?**

Suspense ist nicht ideal für sehr kleine Datenmengen, die synchron im Cache vorliegen sollten. Bei kritischen Above-the-fold-Inhalten sollte der initiale HTML-Response vollständig sein. Auch für Formulare mit optimistischen Updates sind andere Patterns wie `useOptimistic` besser geeignet.

**Frage: Wie verhält sich Suspense mit Error Boundaries?**

Error Boundaries fangen Fehler ab, die während des Renderings auftreten, einschließlich Fehler in Promises, die von Suspense-fähigen Quellen geworfen werden. Die Boundary sollte das Suspense-Element umschließen, um sowohl Render-Fehler als auch Fetch-Fehler abzufangen.

**Frage: Was ist der Selective Hydration-Mechanismus?**

Selective Hydration ermöglicht es React, Teile der Seite unabhängig voneinander zu hydrieren. Wenn ein Benutzer mit einem noch nicht hydrierten Bereich interagiert, priorisiert React dessen Hydration. Dies kombiniert sich mit Suspense Boundaries: Jedes Boundary kann unabhängig hydriert werden.

## Fazit

React 19 mit Suspense und Concurrent Rendering bietet leistungsstarke Werkzeuge für moderne Webanwendungen. Streaming SSR verkürzt die Zeit bis zur ersten sichtbaren Darstellung erheblich, während Concurrent Rendering die Reaktionsfähigkeit der Anwendung verbessert. Das Verständnis dieser Konzepte ist sowohl für die tägliche Entwicklungsarbeit als auch für technische Interviews unerlässlich. Die Kombination aus deklarativem Data Fetching, strategischen Suspense-Boundaries und optimiertem Streaming ermöglicht Benutzererlebnisse, die vor wenigen Jahren noch undenkbar waren.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/de/blog/react-next/react-19-suspense-concurrent-rendering-streaming-ssr