C'è un modo di bloccare un oggetto in Swift come in C#

Question

Ho il codice seguente:

func foo() { 
    var sum = 0 
    var pendingElements = 10 

    for i in 0 ..< 10 { 
     proccessElementAsync(i) { value in 
      sum += value 
      pendingElements-- 

      if pendingElements == 0 { 
       println(sum) 
      } 
     } 
    } 
} 

In questo caso la funzione proccessElementAsync, come indica il nome, processo suo parametro di ingresso asincrono e quando finisce chiama il corrispondente gestore di completamento.

L'inconveniente di questo approccio è che poiché la variabile pendingElements è accessibile tramite più thread, è possibile che l'istruzione if pendingElements == 0 non abbia mai un valore true.

In C# siamo in grado di fare qualcosa di simile:

Object lockObject = new Object(); 
... 

lock (lockObject) { 
    pendingElements--; 

    if (pendingElements == 0) { 
     Console.WriteLine(sum); 
    } 
} 

e questo assicura che questa variabile sarà accessibile solo per un thread allo stesso tempo. C'è un modo per ottenere lo stesso comportamento in Swift?

Answer 1

Spero che questo ti possa aiutare.

func lock(obj: AnyObject, blk:() ->()) { 
    objc_sync_enter(obj) 
    blk() 
    objc_sync_exit(obj) 
} 

var pendingElements = 10 

func foo() { 
    var sum = 0 
    var pendingElements = 10 

    for i in 0 ..< 10 { 
     proccessElementAsync(i) { value in 

      lock(pendingElements) { 
       sum += value 
       pendingElements-- 

       if pendingElements == 0 { 
        println(sum) 
       } 
      } 

     } 
    } 
} 

Answer 2

Non ci sono strumenti di bloccaggio nativi, ma ci sono soluzioni alternative, come spiegato in questa domanda SO:

What is the Swift equivalent to Objective-C's "@synchronized"?

Usando una delle risposte, è possibile creare una funzione:

func synchronize(lockObj: AnyObject!, closure:()->()){ 
     objc_sync_enter(lockObj) 
     closure() 
     objc_sync_exit(lockObj) 
    } 

e quindi:

 func foo() { 
     var sum = 0 
     var pendingElements = 10 

     for i in 0 ..< 10 { 
      processElementAsync(i) { value in 

       synchronize(pendingElements) { 
        sum += value 
        pendingElements-- 

        if pendingElements == 0 { 
         println(sum) 
        } 
       } 

      } 
     } 
    }