Su cosa si basano le barriere e i semafori?

Barriere e semafori nel contesto della programmazione parallela si basano su meccanismi di sincronizzazione:

• Semafori: Si basano su operazioni atomiche su un contatore. Operazioni principali:

  • wait (o P, acquisisci): Decrementa il contatore. Se il contatore diventa negativo, il thread si blocca fino a quando un altro thread esegue signal.
  • signal (o V, rilascia): Incrementa il contatore. Se ci sono thread bloccati, uno di loro si risveglia.
  • I semafori possono essere binari (valore 0 o 1, agiscono come mutex) o contabili (permettono a un numero limitato di thread di accedere alla risorsa).

• Barriere: Si basano su un meccanismo di attesa da parte di tutti i partecipanti. Un thread che raggiunge la barriera si blocca fino a quando tutti gli altri thread coinvolti nella sincronizzazione raggiungono anche questa barriera. Una volta che tutti raggiungono la barriera, continuano simultaneamente.

Nello sviluppo iOS/macOS, questi concetti vengono implementati usando framework di programmazione concorrente come GCD (Grand Central Dispatch) e OperationQueue.

Ad esempio, in GCD:

// Esempio di utilizzo di DispatchSemaphore
let semaphore = DispatchSemaphore(value: 1) // Semaforo binario

// Wait (acquisisci)
semaphore.wait()
// Accesso alla sezione critica
semaphore.signal() // Signal (rilascia)

Le barriere in GCD vengono implementate tramite task di barriera (barrier tasks) per code concorrenti:

let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)

// Task normali
concurrentQueue.async {
    // ...
}

// Task di barriera - eseguito solo quando tutte le task normali precedenti sono terminate
// E dopo questo, nessuna nuova task partirà finché non termina
concurrentQueue.async(flags: .barrier) {
    // ...
}

// Task normali che inizieranno dopo il completamento della task di barriera
concurrentQueue.async {
    // ...
}