Swift 6 Strict Concurrency: Migration Rehberi ve 2026 Production Deneyimi

1// Swift 6 — Concurrency model özeti
2// 1. Structured concurrency: child task, parent'tan kısa ömürlü
3func fetchData() async throws -> [Article] {
4    async let first = fetchPage(1)    // child task
5    async let second = fetchPage(2)  // child task
6    return try await first + second  // her iki task bitince devam
7}
8 
9// 2. Actor: mutable state isolation
10actor ArticleCache {
11    private var cache: [String: Article] = [:]
12 
13    func store(_ article: Article, forKey key: String) {
14        cache[key] = article
15    }
16 
17    func retrieve(forKey key: String) -> Article? {
18        cache[key]
19    }
20}
21 
22// 3. Sendable: domain-safe transfer
23struct Article: Sendable {
24    let id: UUID
25    let title: String
26    let content: String
27    // value type — tüm stored property'ler Sendable ise otomatik
28}

1// YANLIŞ — Swift 6 compile error: class mutable state, non-Sendable
2class UserViewModel {
3    var name: String = ""
4    var age: Int = 0
5}
6 
7// DOĞRU seçenek 1: @MainActor isolation
8@MainActor
9class UserViewModel: ObservableObject {
10    @Published var name: String = ""
11    @Published var age: Int = 0
12    // @MainActor class'lar Sendable sayılır
13}
14 
15// DOĞRU seçenek 2: final + lock
16final class ThreadSafeCache: @unchecked Sendable {
17    private var storage: [String: Any] = [:]
18    private let lock = NSLock()
19 
20    func get(_ key: String) -> Any? {
21        lock.withLock { storage[key] }
22    }
23 
24    func set(_ key: String, value: Any) {
25        lock.withLock { storage[key] = value }
26    }
27}
28 
29// DOĞRU seçenek 3: struct'a dönüştür
30struct UserState: Sendable {
31    var name: String
32    var age: Int
33}

1// Task'a geçirilen closure'lar @Sendable olmalı
2func runInBackground(_ work: @Sendable @escaping() async -> Void) {
3    Task.detached { await work() }
4}
5 
6// Closure capture'da dikkat: mutable variable capture hatası
7var counter = 0
8// HATA: counter var (mutable), farklı task'lardan erişilirse data race
9let task = Task { @Sendable in
10    counter += 1  // Swift 6 ERROR: mutation of captured var in sendable closure
11}
12 
13// DOĞRU: actor veya local copy
14let localCounter = counter
15let task2 = Task { @Sendable in
16    let result = localCounter + 1
17    print(result)
18}

1// Actor isolation örneği
2actor DataStore {
3    private var items: [Item] = []
4 
5    // Isolated method: yalnızca actor executor'unda çalışır
6    func add(_ item: Item) {
7        items.append(item)
8    }
9 
10    // nonisolated: actor hop olmadan çağrılabilir, ama mutable state'e erişemez
11    nonisolated var description: String {
12        "DataStore"  // self.items'a erişemez — compile error
13    }
14}
15 
16// @MainActor class
17@MainActor
18class HomeViewModel: ObservableObject {
19    @Published var articles: [Article] = []
20    @Published var isLoading = false
21 
22    // Bu method otomatik @MainActor — main thread'de çalışır
23    func loadArticles() async {
24        isLoading = true
25        defer { isLoading = false }
26 
27        do {
28            // await ile background'a geç, sonra main'e dön
29            let result = try await ArticleService.shared.fetchAll()
30            articles = result  // main thread — UI güncelleme güvenli
31        } catch {
32            print("Error: \(error)")
33        }
34    }
35}
36 
37// Non-actor context'ten @MainActor'a geçiş
38func processInBackground() async {
39    let data = await fetchHeavyData()
40 
41    // Main actor'a hop: await zorunlu
42    await MainActor.run {
43        // UI güncelleme buraya
44        updateUI(with: data)
45    }
46}

1// Protocol isolation
2@MainActor
3protocol ViewModelProtocol {
4    var isLoading: Bool { get }
5    func load() async
6}
7 
8// Conform eden class otomatik @MainActor
9class ArticleViewModel: ViewModelProtocol {
10    var isLoading = false
11 
12    func load() async {
13        // main actor'da çalışır — herhangi bir @MainActor guard gerekmez
14    }
15}

1// KÖTÜ: Her item için ayrı hop — N item = N*2 hop
2actor ImageProcessor {
3    func processImages(_ urls: [URL]) async -> [UIImage] {
4        var results: [UIImage] = []
5        for url in urls {
6            // Her iteration'da: actor'dan çık → network → actor'a gir
7            let image = await downloadAndProcess(url)
8            results.append(image)
9        }
10        return results
11    }
12 
13    private func downloadAndProcess(_ url: URL) async -> UIImage {
14        // Network I/O — actor suspension
15        let data = try! await URLSession.shared.data(from: url).0
16        return UIImage(data: data) ?? UIImage()
17    }
18}
19 
20// İYİ: Paralel işlem, minimum hop
21actor ImageProcessor {
22    func processImages(_ urls: [URL]) async -> [UIImage] {
23        // Tüm download'ları paralel başlat, actor dışında çalıştır
24        await withTaskGroup(of: UIImage?.self, returning: [UIImage].self) { group in
25            for url in urls {
26                group.addTask {
27                    // Task body actor dışında — hop yok
28                    let data = try? await URLSession.shared.data(from: url).0
29                    return data.flatMap { UIImage(data: $0) }
30                }
31            }
32            return await group.compactMap { $0 }.reduce([]) { $0 + [$1] }
33        }
34    }
35}

1actor AnalyticsEngine {
2    private var events: [Event] = []
3 
4    // isolated — her çağrı actor hop gerektirir
5    func track(_ event: Event) {
6        events.append(event)
7    }
8 
9    // nonisolated computed — hop olmadan okunabilir
10    nonisolated let engineID: UUID = UUID()
11 
12    // nonisolated func — pure computation, actor state yok
13    nonisolated func formatEvent(_ event: Event) -> String {
14        "\(event.name): \(event.timestamp)"
15    }
16}

1func loadDashboard() async throws -> Dashboard {
2    // 3 bağımsız network isteği paralel başlat
3    async let user = fetchUser()
4    async let articles = fetchArticles()
5    async let notifications = fetchNotifications()
6 
7    // Üçü de bitince tuple olarak al
8    let (u, a, n) = try await (user, articles, notifications)
9    return Dashboard(user: u, articles: a, notifications: n)
10}
11// Toplam süre = max(fetchUser, fetchArticles, fetchNotifications)
12// Sequential olsaydı: sum(fetchUser + fetchArticles + fetchNotifications)

1func processAllArticles(_ articles: [Article]) async -> [ProcessedArticle] {
2    await withTaskGroup(of: ProcessedArticle.self) { group in
3        for article in articles {
4            group.addTask {
5                await processArticle(article)
6            }
7        }
8 
9        var results: [ProcessedArticle] = []
10        for await result in group {
11            results.append(result)
12        }
13        return results
14    }
15}
16 
17// ThrowingTaskGroup: hata yönetimi ile
18func fetchAll(_ urls: [URL]) async throws -> [Data] {
19    try await withThrowingTaskGroup(of: Data.self) { group in
20        for url in urls {
21            group.addTask {
22                try await URLSession.shared.data(from: url).0
23            }
24        }
25 
26        var allData: [Data] = []
27        for try await data in group {
28            allData.append(data)
29        }
30        return allData
31    }
32}

1// TaskLocal declaration
2enum RequestContext {
3    @TaskLocal static var requestID: UUID?
4    @TaskLocal static var userID: String?
5    @TaskLocal static var traceDepth: Int = 0
6}
7 
8// Kullanım: withValue ile scope'a gir
9func handleRequest(id: UUID, userID: String) async {
10    await RequestContext.$requestID.withValue(id) {
11        await RequestContext.$userID.withValue(userID) {
12            await processRequest()
13        }
14    }
15}
16 
17// Child task'lar otomatik miras alır
18func processRequest() async {
19    let id = RequestContext.requestID  // set edilmiş değer
20    let user = RequestContext.userID
21 
22    // Child task — parent'tan miras alır
23    async let subResult = subProcess()
24 
25    // TaskGroup child'ları da miras alır
26    await withTaskGroup(of: Void.self) { group in
27        group.addTask {
28            let inherited = RequestContext.requestID  // parent'tan miras
29            await logEvent("processing", requestID: inherited)
30        }
31    }
32}
33 
34// Logging middleware pattern
35func withRequestLogging<T>(
36    _ operation: () async throws -> T
37) async rethrows -> T {
38    let id = UUID()
39    return try await RequestContext.$requestID.withValue(id) {
40        print("[\(id)] Request started")
41        defer { print("[\(id)] Request ended") }
42        return try await operation()
43    }
44}

1// Domain türleri:
2// 1. @MainActor (global actor)
3// 2. Custom actor instance
4// 3. Unstructured (Task.detached, nonisolated)
5 
6// Geçiş matrisi:
7// @MainActor → custom actor: await gerekli
8// custom actor → @MainActor: await gerekli
9// nonisolated → any actor: await gerekli
10// any actor → nonisolated: await gerekli
11 
12actor NetworkLayer {
13    func fetchData() async throws -> Data {
14        // actor içinde — isolated
15        return try await URLSession.shared.data(from: someURL).0
16    }
17}
18 
19@MainActor
20class AppCoordinator {
21    let network = NetworkLayer()
22 
23    func refresh() async {
24        do {
25            // @MainActor → NetworkLayer actor: await ile hop
26            let data = try await network.fetchData()
27 
28            // Geri dönüş: NetworkLayer → @MainActor (otomatik, method @MainActor'da)
29            updateUI(with: data)
30        } catch {
31            showError(error)
32        }
33    }
34}
35 
36// Isolation domain boundary — non-Sendable geçirme hatası
37class NonSendableService {
38    var state: [String] = []
39}
40 
41actor Worker {
42    // HATA: NonSendableService Sendable değil, domain boundary'den geçemez
43    // func process(service: NonSendableService) async { ... }
44 
45    // ÇÖZÜM 1: @preconcurrency ile legacy suppress
46    func process(service: @preconcurrency NonSendableService) async {
47        // uyarı verir ama error değil (Swift 5 compat mode)
48    }
49 
50    // ÇÖZÜM 2: Sendable wrapper
51    func processData(_ data: SendableWrapper) async {
52        // güvenli
53    }
54}

1// Package.swift veya project settings
2// Her flag, Swift 6 özelliğini Swift 5.x'te aktifleştirir
3swiftSettings: [
4    .enableUpcomingFeature("StrictConcurrency"),       // Swift 6'nın core'u
5    .enableUpcomingFeature("GlobalActorIsolatedTypesUsability"),
6    .enableUpcomingFeature("IsolatedDefaultValues"),
7    .enableExperimentalFeature("StrictConcurrency=targeted"),
8]

1Öneri sırası:
21. Network/Data katmanı (pure functions, value types kolay)
32. ViewModel katmanı (@MainActor ile)
43. Service katmanları (actor'a dönüştür)
54. Legacy bridge code(en son, @preconcurrency ile)

1// Henüz migrate edilmemiş library import'ları
2@preconcurrency import LegacyFramework
3 
4// Henüz Sendable olmayan protocol
5@preconcurrency
6protocol LegacyDelegate: AnyObject {
7    func didComplete(_ result: Any)
8}
9 
10// Sendable olmayan completion handler geçici suppress
11func legacyAPICall(completion: @escaping @Sendable (Result<Data, Error>) -> Void) {
12    // @Sendable ile type-safe
13}

1SWIFT_STRICT_CONCURRENCY = minimal    → sadece explicit async/await hataları
2SWIFT_STRICT_CONCURRENCY = targeted  → Sendable uyarıları (hata değil)
3SWIFT_STRICT_CONCURRENCY = complete  → Swift 6 tam enforcement(hata)

11. "Sending 'x' risks causing data races"
2   → x, Sendable değil ve farklı isolation domain'e geçiyor
3   → Çözüm: x'i Sendable yap veya actor ile wrap et
4 
52. "Main actor-isolated property 'x' can not be mutated from a nonisolated context"
6   → @MainActor property'yi background thread'den değiştirmeye çalışıyorsun
7   → Çözüm: await MainActor.run { ... }
8 
93. "Passing closure as a 'Sendable' parameter"
10   → Closure Sendable değil ama Sendable bekleniyor
11   → Çözüm: Closure'u @Sendable yap, capture'ları Sendable yap
12 
134. "Actor-isolated instance method 'x' cannot be referenced from outside the actor"
14   → await kullanmadan actor method çağırıyorsun
15   → Çözüm: await ekle veya nonisolated yap

1// Firebase callback-based API, Swift 6 ile uyarı verir
2// @preconcurrency import ile suppress
3@preconcurrency import FirebaseFirestore
4 
5@MainActor
6class ArticleRepository {
7    private let db = Firestore.firestore()
8 
9    func fetchArticles() async throws -> [Article] {
10        let snapshot = try await db.collection("articles").getDocuments()
11        // Firestore'dan gelen data main actor'da process et
12        return snapshot.documents.compactMap { doc in
13            try? doc.data(as: Article.self)
14        }
15    }
16}

1// HATA
2class Config {  // Sendable değil
3    var apiKey: String = ""
4}
5 
6actor APIClient {
7    func configure(with config: Config) {  // ERROR: Config not Sendable
8        // ...
9    }
10}
11 
12// ÇÖZÜM A: Struct'a dönüştür
13struct Config: Sendable {
14    let apiKey: String
15}
16 
17// ÇÖZÜM B: nonisolated init + snapshot
18actor APIClient {
19    private var apiKey: String = ""
20 
21    func configure(apiKey: String) {  // primitive geçir
22        self.apiKey = apiKey
23    }
24}

1// HATA: var capture in @Sendable closure
2var results: [String] = []
3let task = Task {
4    results.append("data")  // ERROR: mutation of captured 'var'
5}
6 
7// ÇÖZÜM: Actor veya withTaskGroup kullan
8actor ResultCollector {
9    private var results: [String] = []
10 
11    func add(_ item: String) {
12        results.append(item)
13    }
14 
15    func getAll() -> [String] { results }
16}

1@MainActor func updateUI() { ... }
2 
3// Background Task'ta — HATA
4Task.detached {
5    updateUI()  // ERROR: cannot be called without await
6}
7 
8// ÇÖZÜM
9Task.detached {
10    await updateUI()
11}

1// KÖTÜ: Her resource için ayrı actor
2actor UserActor { var user: User? }
3actor SessionActor { var session: Session? }
4actor TokenActor { var token: String? }
5 
6// İYİ: İlgili state bir arada
7actor AppSession {
8    var user: User?
9    var session: Session?
10    var token: String?
11}

1func processLargeDataset(_ items: [Item]) async throws -> [Result] {
2    var results: [Result] = []
3    for item in items {
4        try Task.checkCancellation()  // Her iteration'da check
5        let result = try await process(item)
6        results.append(result)
7    }
8    return results
9}

1@Observable @MainActor
2class FeedViewModel {
3    var articles: [Article] = []
4    var isLoading = false
5 
6    // @Published gerekmez — @Observable otomatik tracking
7    func refresh() async {
8        isLoading = true
9        articles = try! await ArticleService.shared.fetchAll()
10        isLoading = false
11    }
12}

1// XCTest + Swift 6
2@MainActor
3final class ViewModelTests: XCTestCase {
4    func testLoad() async throws {
5        let vm = HomeViewModel()
6        await vm.load()
7        XCTAssertFalse(vm.articles.isEmpty)
8    }
9}

1@MainActor
2protocol ViewModel: AnyObject, ObservableObject {
3    associatedtype State
4    var state: State { get }
5    func onAppear() async
6    func onDisappear()
7}
8 
9// Tüm conform eden tipler otomatik @MainActor
10class HomeViewModel: ViewModel {
11    // @MainActor explicit yazmana gerek yok — protocol'den miras
12    var state: HomeState = .init()
13 
14    func onAppear() async {
15        await loadData()  // main actor'da
16    }
17}

1// Distributed Actor — iki process/device arasında
2distributed actor GameSession {
3    var score: Int = 0
4 
5    distributed func addScore(_ points: Int) {
6        score += points
7    }
8}
9 
10// Kullanım — sanki local gibi, ama network üzerinden
11let session = try GameSession(actorSystem: ClusterSystem.shared)
12try await session.addScore(10)
13// Distributed runtime: serialization, network, error handling otomatik