Cos'è un attore nel contesto dello sviluppo software?

Nel contesto dello sviluppo software, un attore è una primitiva computazionale indipendente che incapsula stato e comportamento. Comunica con altri attori esclusivamente tramite messaggi.

Proprietà principali degli attori:

• Stato isolato: Lo stato di ogni attore è accessibile solo dall'attore stesso. Ciò impedisce modifiche dirette ai dati dall'esterno e semplifica la gestione dei flussi di dati.
• Trasmissione di messaggi: L'attore comunica con altri attori inviando e ricevendo messaggi asincroni. I messaggi vengono elaborati in modo sequenziale.
• Indipendenza: L'attore svolge il suo lavoro in modo indipendente dagli altri attori, senza bloccarli.
• Indirizzabilità: Ogni attore ha un indirizzo unico a cui può essere inviato un messaggio.

Nello sviluppo iOS, actor è una nuova primitive di parallelismo introdotta in Swift 5.5. Garantisce un accesso sicuro allo stato modificabile in ambienti multithread.

Caratteristiche di actor in Swift:

• Isolamento dello stato: Tutte le proprietà e i metodi dell'attore vengono eseguiti in un singolo thread, garantendo un accesso sicuro allo stato modificabile.
• Accesso asincrono: L'accesso alle proprietà e ai metodi dell'attore dall'esterno è asincrono e richiede l'uso di await. Il sistema garantisce che l'accesso simultaneo allo stato dell'attore venga coordinato.
• nonisolated: Con la parola chiave nonisolated, è possibile contrassegnare proprietà o metodi che non richiedono isolamento e sono accessibili senza await.
• isolated: Con la parola chiave isolated, è possibile indicare esplicitamente che un parametro di metodo è isolato e appartiene all'attore.

Esempio di utilizzo di actor in Swift:

actor Counter {
    private var value: Int = 0 // Stato isolato

    func increment() {
        value += 1
    }

    func getValue() -> Int {
        return value
    }
}

func updateCounter() async {
    let counter = Counter()
    await counter.increment() // Chiamata asincrona
    let currentValue = await counter.getValue() // Chiamata asincrona
    print(currentValue)
}

// Chiamata di funzione async
Task {
    await updateCounter()
}

L'uso degli attori semplifica la scrittura di codice sicuro multithread, eliminando la necessità di blocchi espliciti e sincronizzazione per proteggere lo stato modificabile condiviso.