0Pricing
Swift Academy · Lekcja

Aktory: ochrona współdzielonego zmiennego stanu

Używanie actor do szeregowania dostępu i zapobiegania wyścigom danych podczas kompilacji.

Aktory: ochrona współdzielonego zmiennego stanu to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Aktory języka Swift chronią współdzielony, zmienny stan przed równoczesnym dostępem za pomocą *izolacji aktora*. Zapewniają bezpieczną współbieżność bez ręcznego używania blokad.

Definiowanie aktora

```swift actor Counter { var count = 0 func increment() { count += 1 } func value() -> Int { count } } ```

Dostęp do stanu aktora

```swift let counter = Counter() await counter.increment() // await required for external access let v = await counter.value() ``` Wszystkie wywołania między aktorami są asynchroniczne — czekają na swoją kolej u aktora.

Izolacja danych

```swift actor BankAccount { private var balance: Double = 0 func deposit(_ amount: Double) { balance += amount } func withdraw(_ amount: Double) throws { guard amount <= balance else { throw BankError.insufficient } balance -= amount } } ```

nonisolated

```swift actor Config { nonisolated let appName: String = "CoddyKit" // safe to access without await var settings: [String:String] = [:] } let name = Config().appName // no await needed ```

@MainActor

```swift @MainActor class ViewController { var label = UILabel() func updateText(_ text: String) { label.text = text // guaranteed on main thread } } ``` `@MainActor` to specjalny aktor działający w głównym wątku.

Wymóg Sendable

Typy przekazywane między granicami aktorów muszą być zgodne z `Sendable`: ```swift struct Message: Sendable { var text: String; var timestamp: Date } await actor.receive(message) // safe — Message is Sendable ```

Aktor a klasa

| Cecha | Actor | Class | |---|---|---| | Bezpieczeństwo współbieżności | ✓ | ✗ | | Typ referencyjny | ✓ | ✓ | | Dziedziczenie | ✗ | ✓ | | Dostęp asynchroniczny | ✓ | — |

Aktory nie powodują zakleszczeń

W przeciwieństwie do blokad aktory nie mogą powodować zakleszczeń, ale mogą prowadzić do *ponownego wejścia do aktora*, gdy aktor oczekuje na innego aktora, a w międzyczasie nadejdzie drugie wywołanie.

Aktory globalne

```swift @globalActor struct DatabaseActor { static let shared = Actor() actor Actor {} } @DatabaseActor func save() { ... } ```

Szybkie sprawdzenie

Dlaczego zewnętrzny dostęp do właściwości aktora musi używać `await`?

Podsumowanie

Najważniejsze informacje: • Aktory chronią zmienny stan — w danym momencie działa tylko jedno zadanie • Dostęp zewnętrzny wymaga `await` • `nonisolated` służy do oznaczania bezpiecznych, nieizolowanych elementów • `@MainActor` — działa w głównym wątku; należy używać go do obsługi interfejsu użytkownika • Typy przekraczające granice aktorów muszą być zgodne z `Sendable` Kurs ukończony! Dalej: zaawansowane typy generyczne.

Często zadawane pytania

Czy lekcja „Aktory: ochrona współdzielonego zmiennego stanu” jest bezpłatna?

Tak — pełny tekst „Aktory: ochrona współdzielonego zmiennego stanu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Aktory: ochrona współdzielonego zmiennego stanu”?

Używanie actor do szeregowania dostępu i zapobiegania wyścigom danych podczas kompilacji. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Aktory: ochrona współdzielonego zmiennego stanu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Składnia async/await i wywoływanie funkcji asynchronicznych
  2. Task i anulowanie zadań
  3. async let i współbieżne zadania potomne
  4. Aktory: ochrona współdzielonego zmiennego stanu
← Powrót do Swift Academy