Swift Academy · Lektion

Auf Strict Concurrency migrieren

Führen Sie die Nebenläufigkeitsprüfung von Swift 6 schrittweise ein.

Lektion 4 von 413 Schritte

Auf Strict Concurrency migrieren ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist strikte Nebenläufigkeit?

Strenge Nebenläufigkeitsprüfung veranlasst den Compiler, jedes mögliche Datenrennen bereits zur Compilezeit zu diagnostizieren.

Im Swift-6-Sprachmodus ist sie standardmäßig aktiviert; im Swift-5-Modus aktivieren Sie sie schrittweise.

Die drei Prüfungsstufen

Das -strict-concurrency-Flag hat drei Stufen: minimal (Standard in Swift 5), targeted (prüft Code, der bereits Nebenläufigkeit verwendet) und complete (vollständige Prüfung nach dem Swift-6-Modell).

// Build settings example
// SWIFT_STRICT_CONCURRENCY = complete

Schrittweise Einführung

Der empfohlene Weg besteht darin, die Stufen schrittweise zu erhöhen: Beginnen Sie mit targeted, beheben Sie die Warnungen und wechseln Sie anschließend zu complete, bevor Sie den Sprachmodus auf 6 umstellen.

So bleibt die Migration auch bei großen Codebasen überschaubar.

// Step 1: targeted
// Step 2: complete (warnings)
// Step 3: Swift 6 mode (errors)

Migration pro Modul

Die strenge Nebenläufigkeitsprüfung wird pro Target festgelegt. Sie können ein Modul nach dem anderen migrieren und die übrigen Module im Swift-5-Modus lassen, bis sie bereit sind.

// Package.swift target
// swiftSettings: [.enableExperimentalFeature("StrictConcurrency")]

Häufige Warnung: Erfassen eines nicht Sendable-Werts

Die häufigste Diagnose betrifft das Erfassen eines nicht Sendable-Werts in einem Task oder das Übertragen dieses Werts über eine Actor-Grenze hinweg.

Beheben Sie das Problem, indem Sie den Typ Sendable machen oder nur Sendable-Daten herauskopieren.

final class Model { var name = "" }
func start(_ m: Model) {
    // Warning: non-Sendable Model captured by Task
    // Task { print(m.name) }
}

Beheben mit Werttypen

Oft besteht die sauberste Lösung darin, Daten als unveränderlichen Werttyp zu modellieren, der automatisch Sendable ist.

struct Model: Sendable { let name: String }
func start(_ m: Model) {
    Task { print(m.name) } // safe now
}

Beheben mit @MainActor

Bei UI-Typen treten häufig Warnungen auf, weil von Hintergrund-Tasks auf sie zugegriffen wird. Wenn Sie den Typ mit @MainActor annotieren, binden Sie ihn an den Hauptthread und beheben die Warnungen.

@MainActor
final class ViewModel {
    var items: [String] = []
    func reload() async {
        let fetched = await load()
        items = fetched
    }
}
func load() async -> [String] { [] }

Sendable-Konformität für vorhandene Typen

Fügen Sie für Typen, die Sie kontrollieren und die bereits threadsicher sind, explizit die Konformität zu Sendable oder @unchecked Sendable hinzu, um Warnungen auf ehrliche Weise zu beheben.

import Foundation
final class Counter: @unchecked Sendable {
    private let lock = NSLock()
    private var n = 0
}

Preconcurrency-Imports

Wenn eine Abhängigkeit ihre API noch nicht annotiert hat, lockert @preconcurrency import die Prüfung für dieses Modul und stuft Fehler so lange zu Warnungen herab, bis das Modul aktualisiert wurde.

@preconcurrency import SomeLegacyFramework

Symbole mit @preconcurrency markieren

Sie können einzelne Deklarationen ebenfalls mit @preconcurrency markieren, damit Aufrufer aus älterem Code keine Fehler erhalten, wenn Sie Sendable-Anforderungen hinzufügen.

@preconcurrency
func handle(_ value: Sendable) { }

Überprüfen der Migration

Wenn die Prüfung mit complete keine Warnungen mehr erzeugt, stellen Sie das Target auf den Swift-6-Modus um. Dadurch werden die Garantien als verbindliche Fehler durchgesetzt und können nicht wieder verloren gehen.

// Package.swift
// .target(name: "App", swiftSettings: [.swiftLanguageMode(.v6)])

Schnelltest: Migration

Testen Sie Ihr Verständnis der Migration zur strengen Nebenläufigkeit.

Beantworte es in der interaktiven Lektion

Zusammenfassung: Migration zur strengen Nebenläufigkeit

Die strenge Nebenläufigkeitsprüfung verlagert die Erkennung von Datenrennen in die Compilezeit und bietet die Stufen minimal, targeted und complete. Migrieren Sie pro Modul, beheben Sie das Erfassen nicht Sendable-fähiger Werte mit Werttypen, @MainActor oder einer ehrlichen Sendable-Konformität und verwenden Sie @preconcurrency, um die Interoperabilität mit noch nicht migrierten Abhängigkeiten zu erleichtern.

Sobald complete keine Warnungen mehr erzeugt, aktivieren Sie den Swift-6-Modus, um die Garantien dauerhaft festzuschreiben.

Kostenlos starten

Lerne Swift mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 122
Lektionen: 409

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Auf Strict Concurrency migrieren“ kostenlos?

Ja — der vollständige Text von „Auf Strict Concurrency migrieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Auf Strict Concurrency migrieren“?

Führen Sie die Nebenläufigkeitsprüfung von Swift 6 schrittweise ein. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Auf Strict Concurrency migrieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Swift Academy