Lista de seguridad <T> hilo

Question

Estoy utilizando el código de abajo

var processed = new List<Guid>(); 
Parallel.ForEach(items, item => 
{ 
    processed.Add(SomeProcessingFunc(item)); 
}); 

es el hilo conductor el código de seguridad? ¿Hay alguna posibilidad de que la lista procesada se corrompa? ¿O debería usar un candado antes de agregar?

var processed = new List<Guid>(); 
Parallel.ForEach(items, item => 
{ 
    lock(items.SyncRoot) 
     processed.Add(SomeProcessingFunc(item)); 
}); 

gracias.

Answer 1

No! No es seguro en absoluto, porque processed.Add no lo es. Puede hacer lo siguiente:

items.AsParallel().Select(item => SomeProcessingFunc(item)).ToList(); 

Tenga en cuenta que Parallel.ForEach fue creado principalmente para imperativas operaciones para cada elemento de la secuencia. Lo que haces es un mapa: proyecta cada valor de secuencia. Para eso se creó Select. AsParallel lo escala entre subprocesos de la manera más eficiente.

Este código funciona correctamente:

var processed = new List<Guid>(); 
Parallel.ForEach(items, item => 
{ 
    lock(items.SyncRoot) 
     processed.Add(SomeProcessingFunc(item)); 
}); 

pero no tiene sentido en términos de múltiples hilos. lock ing en cada iteración obliga a la ejecución totalmente secuencial, el grupo de subprocesos estará esperando un subproceso único.

Answer 2

citar Jon Skeet antes de que llegue aquí:

Como parte de las extensiones Parellel en .Net 4, hay varias nuevas colecciones en un nuevo espacio de nombres System.Collections.Concurrent . Estos están diseñados para ser seguros frente a las operaciones concurrentes de varios hilos, con relativamente poco bloqueo.

Incluyen IProducerConsumerCollection<T>, BlockingCollection<T>, ConcurrentBag<T>, ConcurrentQueue<T>, ConcurrentStack<T>, and ConcurrentDictionary<TKey, TValue> entre otros.

Answer 3

Uso:

var processed = new ConcurrentBag<Guid>(); 

Ver parallel foreach loop - odd behavior.

Answer 4

lectura es seguro para subprocesos, pero no es así. Necesita una configuración de bloqueo de lector/escritor ya que la adición puede hacer que la matriz interna cambie el tamaño, lo que estropearía una lectura simultánea.

Si puede garantizar que la matriz no cambiará de tamaño al agregar, puede estar seguro de agregar mientras lee, pero no me cite al respecto.

Pero en realidad, una lista es solo una interfaz para una matriz.

Answer 5

Como alternativa a la answer de Andrey:

items.AsParallel().Select(item => SomeProcessingFunc(item)).ToList(); 

También podría escribir

items.AsParallel().ForAll(item => SomeProcessingFunc(item)); 

Esto hace que la consulta que está detrás de él aún más eficiente porque no se requiere de combinación, MSDN. Asegúrese de que la función SomeProcessingFunc es segura para subprocesos. Y creo, pero no lo he probado, que todavía necesita un bloqueo si la lista se puede modificar en otro hilo (agregando o eliminando) elementos.

Answer 6

Uso ConcurrentBag de tipo Algo

var bag = new ConcurrentBag<List<Something>>; 
var items = GetAllItemsINeed(); 
Parallel.For(items,i =>       
    { 
     bag.Add(i.DoSomethingInEachI()); 
    });