modifica gli elenchi da un altro thread, mentre l'iterazione (C#)

Question

Sto scorrendo un elenco di elementi con foreach, in questo modo:

foreach (Type name in aList) { 
    name.doSomething(); 
} 

Tuttavia, in un altro thread che io chiamo qualcosa come

aList.Remove(Element); 

Durante il runtime, ciò provoca un'eccezione InvalidOperationException: Collection è stata modificata; l'operazione di enumerazione potrebbe non essere eseguita. Qual è il modo migliore per gestirlo (lo farei essere piuttosto semplice anche a costo di prestazioni)?

Grazie!

Answer 1

Discussione A:

lock (aList) { 
    foreach (Type name in aList) { 
    name.doSomething(); 
    } 
} 

Discussione B:

lock (aList) { 
    aList.Remove(Element); 
} 

Questo naturalmente è davvero male per le prestazioni.

Answer 2

Qual è il modo migliore per gestirlo (vorrei renderlo piuttosto semplice anche a costo di prestazioni)?

Fondamentalmente: non provare a modificare una raccolta senza thread da più thread senza bloccare. Il fatto che stai iterando è per lo più irrilevante qui - ti ha semplicemente aiutato a trovarlo più velocemente. Sarebbe stato insicuro che due thread chiamassero allo stesso tempo Remove allo stesso tempo.

O utilizzare una collezione di thread-safe, come ConcurrentBago assicurarsi che solo un thread fa nulla con la raccolta in un momento.

Answer 3

se si desidera solo per evitare l'eccezione utilizzare

foreach (Type name in aList.ToArray()) 
{ name.doSomething(); } 

essere consapevoli del doSomething() viene eseguito anche nel caso l'elemento è stato rimosso in altro thread

Answer 4

non posso in particolare raccontare dalla domanda, ma (sembra) si sta eseguendo un'azione su ogni elemento e quindi rimuoverlo. Potresti voler dare un'occhiata a BlockingCollection<T>, che ha un metodo che chiama GetConsumingEnumerable() per vedere se è adatto a te. Ecco un piccolo esempio.

void SomeMethod() 
{ 
    BlockingCollection<int> col = new BlockingCollection<int>(); 

    Task.StartNew(() => { 

     for (int j = 0; j < 50; j++) 
     { 
      col.Add(j); 
     } 

     col.CompleteAdding(); 

    }); 

    foreach (var item in col.GetConsumingEnumerable()) 
    { 
     //item is removed from the collection here, do something 
     Console.WriteLine(item); 
    } 
} 

Answer 5

Se si dispone di più di un lettore, quindi provare un blocco Reader-Writer (Net 3.5+), Slim: http://msdn.microsoft.com/en-us/library/system.threading.readerwriterlockslim.aspx

Se v'è solo un lettore, il solo una serratura sulla lista stessa o su un oggetto privato (ma non bloccare il tipo stesso), come mostrato nella risposta di Eugen Rieck.

Answer 6

Metodo # 1:

Il metodo più semplice e meno efficiente è quello di creare una sezione critica per i lettori e scrittori.

// Writer 
lock (aList) 
{ 
    aList.Remove(item); 
} 

// Reader 
lock (aList) 
{ 
    foreach (T name in aList) 
    { 
    name.doSomething(); 
    } 
} 

Metodo # 2:

Questo è simile al metodo # 1, ma invece di tenere il blocco per tutta la durata del ciclo foreach si dovrebbe copiare la raccolta e poi iterare il copia.

// Writer 
lock (aList) 
{ 
    aList.Remove(item); 
} 

// Reader 
List<T> copy; 
lock (aList) 
{ 
    copy = new List<T>(aList); 
} 
foreach (T name in copy) 
{ 
    name.doSomething(); 
} 

Metodo # 3:

Tutto dipende dalla vostra situazione specifica, ma il modo in cui io di solito affrontare questo è quello di mantenere il riferimento principale per la raccolta immutabile. In questo modo non dovrai mai sincronizzare l'accesso dal lato del lettore. Il lato scrittore delle cose ha bisogno di un lock. Il lato lettore non ha bisogno di nulla, il che significa che i lettori rimangono altamente concomitanti. L'unica cosa che devi fare è contrassegnare il riferimento aList come volatile.

// Variable declaration 
object lockref = new object(); 
volatile List<T> aList = new List<T>(); 

// Writer 
lock (lockref) 
{ 
    var copy = new List<T>(aList); 
    copy.Remove(item); 
    aList = copy; 
} 

// Reader 
List<T> local = aList; 
foreach (T name in local) 
{ 
    name.doSomething(); 
}