Come posso tenere traccia di quante attività asincrone sono state completate in un ciclo?

Question

Ho un codice che scorre un elenco di record, avvia un'attività di esportazione per ciascuno e aumenta un contatore di avanzamento di 1 ogni volta che un'attività termina, in modo che l'utente sappia quanto è lungo il processo.

Ma a seconda del tempo dei miei loop, vedo spesso l'output che mostra un numero più alto prima di un numero inferiore.

Per esempio, mi sarei aspettato di vedere l'uscita in questo modo:

 
Exporting A 
Exporting B 
Exporting C 
Exporting D 
Exporting E 
Finished 1/5 
Finished 2/5 
Finished 3/5 
Finished 4/5 
Finished 5/5 

Ma invece io ottenere output come questo

 
Exporting A 
Exporting B 
Exporting C 
Exporting D 
Exporting E 
Finished 1/5 
Finished 2/5 
Finished 5/5 
Finished 4/5 
Finished 3/5 

Non mi aspetto che l'uscita per l'esattezza da quando ho' m non blocca il valore quando lo aggiorno/utilizzo (a volte emette lo stesso numero due volte o salta un numero), tuttavia non mi aspetto che vada indietro.

Il mio set di dati di test è di 72 valori, e il relativo codice è simile al seguente:

var tasks = new List<Task>(); 
int counter = 0; 

StatusMessage = string.Format("Exporting 0/{0}", count); 

foreach (var value in myValues) 
{ 
    var valueParam = value; 

    // Create async task, start it, and store the task in a list 
    // so we can wait for all tasks to finish at the end 
    tasks.Add(
     Task.Factory.StartNew(() => 
     { 
      Debug.WriteLine("Exporting " + valueParam); 

      System.Threading.Thread.Sleep(500); 
      counter++; 
      StatusMessage = string.Format("Exporting {0}/{1}", counter, count); 

      Debug.WriteLine("Finished " + counter.ToString()); 
     }) 
    ); 
} 

// Begin async task to wait for all tasks to finish and update output 
Task.Factory.StartNew(() => 
{ 
    Task.WaitAll(tasks.ToArray()); 
    StatusMessage = "Finished"; 
}); 

L'uscita può apparire invertiti in entrambe le istruzioni di debug e il StatusMessage uscita.

Qual è il modo corretto per tenere il conto di quante attività asincrone in un ciclo sono state completate in modo che questo problema non si verifichi?

Answer 1

Si ottiene uscita miscelata, perché contatore non viene incrementato nello stesso ordine Debug.WriteLine(...) metodo è eseguito.

Per ottenere una relazione coerente, è possibile introdurre un blocco di segnalazione nel compito

tasks.Add(
    Task.Factory.StartNew(() => 
    { 
     Debug.WriteLine("Exporting " + valueParam); 

     System.Threading.Thread.Sleep(500); 
     lock(progressReportLock) 
     { 
      counter++; 
      StatusMessage = string.Format("Exporting {0}/{1}", counter, count); 
      Debug.WriteLine("Finished " + counter.ToString()); 
     } 
    }) 
); 

Answer 2

In questo esempio la variabile counter rappresenta lo stato condiviso tra più thread. L'utilizzo dell'operatore ++ sullo stato condiviso non è sicuro e fornirà risultati non corretti. Si riduce essenzialmente le seguenti istruzioni

1. contatore spinta per impilare
2. spinta 1 impilare
3. aggiungere valori in pila
4. deposito nel contatore

Poiché più thread sono in esecuzione questa affermazione è possibile per uno di interrompere l'altra parte completando la sequenza di cui sopra. Ciò farebbe sì che il valore errato finisse in counter.

Invece di ++ usa la seguente istruzione

Interlocked.Increment(ref counter); 

Questa operazione è specificamente progettato per aggiornare lo stato che può essere condiviso tra più thread. L'interblocco avverrà atomicamente e non risentirà delle condizioni di gara che ho delineato

L'effettiva visualizzazione dei valori fuori uso soffre di un problema simile anche dopo la mia soluzione suggerita. L'operazione di incremento e visualizzazione non è atomica e quindi un thread può interrompere l'altro tra l'incremento e la visualizzazione. Se si desidera che le operazioni siano interrompibili da altri thread, sarà necessario utilizzare un blocco.

object lockTarget = new object(); 
int counter = 0; 

... 

lock (lockTarget) { 
    counter++; 
    StatusMessage = string.Format("Exporting {0}/{1}", counter, count); 
    Debug.WriteLine("Finished " + counter.ToString()); 
} 

noti che poiché l'incremento di counter ora avviene all'interno della serratura non v'è la necessità di utilizzare Interlocked.Increment