0Pricing
Swift Academy · Lekcja

Aktory i izolacja danych, nonisolated

Poznaj izolację aktorów: stan jest chroniony za obiektem actor , dostęp między aktorami wymaga await , a elementy nonisolated omijają izolację, gdy są czyste lub statyczne.

Aktory i izolacja danych, nonisolated to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 z 3. 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 3 lekcji w sumie.

Co zapewniają aktory

Aktor chroni swój zmienny stan. Tylko jedno zadanie naraz uzyskuje dostęp do izolowanego stanu; zewnętrzni wywołujący muszą używać await do wywoływania jego metod.

  • Izolacja = brak wyścigów danych
  • Wywołania między aktorami są asynchroniczne
  • nonisolated dla czystych lub statycznych elementów

Podstawy aktorów

Wewnątrz aktora dostęp jest bezpośredni. Z zewnątrz musisz używać await zarówno podczas odczytu, jak i zapisu izolowanego stanu.

actor Counter {
    private var value: Int = 0   // isolated state

    func increment() { value += 1 }      // isolated method (async to outsiders)
    func get() -> Int { value }          // read isolated state
}

let c = Counter()
Task {
    await c.increment()
    print(await c.get())  // 1
}

Gwarancja serializacji

Nawet jeśli wiele zadań wywołuje aktora równocześnie, aktor serializuje dostęp do swojego stanu, zapobiegając wyścigom.

actor BankAccount {
    private var balance: Int = 0
    func deposit(_ amount: Int) { balance += amount }
    func withdraw(_ amount: Int) -> Bool {
        if balance >= amount { balance -= amount; return true }
        return false
    }
    func current() -> Int { balance }
}

let acc = BankAccount()
Task {
    async let a = acc.deposit(50)
    async let b = acc.withdraw(20)
    _ = await (a, b)                 // operations are serialized inside the actor
    print(await acc.current())       // deterministic balance
}

API nonisolated

Oznacz elementy jako nonisolated, jeśli są czyste lub statyczne, aby wywołujący nie musieli używać await. Takie elementy nie mogą uzyskiwać dostępu do izolowanego stanu.

actor Clock {
    private var ticks: Int = 0
    func tick() { ticks += 1 }
    func read() -> Int { ticks }

    // Nonisolated: safe without awaiting (pure computation / constant)
    nonisolated static let format = "HH:mm:ss"

    nonisolated func describeFormat() -> String {
        // Cannot touch isolated state here; this is pure
        return "Format: " + Self.format
    }
}

let cl = Clock()
Task {
    await cl.tick()
    print(await cl.read())           // 1
    // Nonisolated members don't require await:
    print(Clock.format)              // "HH:mm:ss"
    print(cl.describeFormat())       // sync call
}

Świadomość reentrancyjności

Aktory mogą być reentrant: po wykonaniu await wewnątrz metody aktora mogą zostać obsłużone inne komunikaty. Zachowuj niezmienniki w każdym punkcie await.

actor Logger {
    private var lines: [String] = []
    func log(_ s: String) async {
        lines.append(s)
        // Simulate an await point; actor may process other messages here (reentrant)
        try? await Task.sleep(nanoseconds: 10_000_000)
        lines.append("done")
    }
    func snapshot() -> [String] { lines }
}

let logger = Logger()
Task {
    async let a = logger.log("A")
    async let b = logger.log("B")
    _ = await (a, b)
    print(await logger.snapshot())   // order shows possible interleaving
}

Dobre praktyki

Wskazówki:

  • Udostępniaj małe metody asynchroniczne; unikaj długich sekcji krytycznych.
  • Używaj nonisolated dla stałych i czystych funkcji pomocniczych.
  • Nie przechowuj współdzielonego, zmiennego stanu niezgodnego z Sendable poza aktorami (element Sendable poznasz w następnej lekcji).

Wymóg izolacji aktora

Szybkie sprawdzenie: Jak odczytywać lub zapisywać stan aktora z zewnątrz?

Podsumowanie

Podsumowanie: Aktory izolują zmienny stan, a dostęp z zewnątrz wymaga użycia await. Stosuj nonisolated dla czystych lub statycznych elementów i projektuj krótkie metody asynchroniczne, aby bezpiecznie obsługiwać reentrancyjność.

Często zadawane pytania

Czy lekcja „Aktory i izolacja danych, nonisolated” jest bezpłatna?

Tak — pełny tekst „Aktory i izolacja danych, nonisolated” 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 3 lekcji w sumie.

Co nauczysz się w „Aktory i izolacja danych, nonisolated”?

Poznaj izolację aktorów: stan jest chroniony za obiektem actor , dostęp między aktorami wymaga await , a elementy nonisolated omijają izolację, gdy są czyste lub statyczne. Ć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 2 z 3.

Ile czasu zajmuje lekcja „Aktory i izolacja danych, nonisolated”?

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. TaskGroup do wykonywania równoległego
  2. Aktory i izolacja danych, nonisolated
  3. Sendable i sprawdzanie bezpieczeństwa wątkowego
← Powrót do Swift Academy