3. Teori: Memory Model & Concurrency Ownership

Swift Concurrency Memory Model

Swift Concurrency menggunakan model memori berbasis isolation domains. Setiap isolation domain memiliki "ownership" atas data mutasinya:

swift
┌─────────────────────────────────────────────────────┐
│                  Program Memory                      │
│                                                     │
│  ┌─────────────────┐   ┌─────────────────────────┐  │
│  │  @MainActor     │   │  actor DatabaseActor    │  │
│  │  Domain         │   │  Domain                 │  │
│  │                 │   │                         │  │
│  │  viewModel      │   │  records: [Record]      │  │
│  │  uiState        │   │  indices: [Index]       │  │
│  └────────┬────────┘   └─────────────────────────┘  │
│           │                                          │
│           │ Sendable values only                     │
│           ↓                                          │
│  ┌─────────────────┐                                │
│  │  Unstructured   │                                │
│  │  Task / Detached│                                │
│  │  Task Domain    │                                │
│  └─────────────────┘                                │
└─────────────────────────────────────────────────────┘

Aturan fundamental:

Nilai mutable dalam satu domain tidak boleh diakses dari domain lain
Untuk memindahkan nilai antar domain, nilai harus Sendable
Sendable berarti: nilai aman untuk dikopi atau dipindah tanpa menyebabkan data race

Ownership dan Lifetimes

Swift 6 memperkenalkan region-based isolation — konsep bahwa nilai memiliki "region" dan compiler melacak apakah region tersebut sudah "dikirim" ke domain lain. Setelah dikirim, nilai dalam region yang sama tidak bisa diakses lagi dari context asli.

swift
// Ilustrasi region-based isolation
func processOrder() async {
    var order = Order(items: [.init(name: "Coffee")])
    // order ada di region "local"
    
    // 'sending' keyword: transfer ownership ke domain lain
    await paymentService.process(sending order)
    // Setelah ini, 'order' tidak bisa diakses lagi di function ini
    // Compiler error jika mencoba akses order setelah ini
}

Happens-Before Relationship

Swift Concurrency menggunakan konsep happens-before dari memory model formal:

Semua operasi sebelum await happens-before operasi setelah await
Semua operasi dalam actor method berjalan secara serial — ada total ordering
Task creation happens-before first operation di task tersebut