C# Threadpool Synchronization Inquiry

Question

Je rencontre un peu de difficulté en utilisant la classe threadpool et un tableau de ManualResetEvents. Voici un exemple simple de ce que je fais. Le problème est que dans la méthode DoWork j'obtiens des références nulles à l'objet resetEvent [param as int].

Je n'arrive pas à comprendre ce que je fais de mal.

(edit: a obtenu le fonctionnement du bloc de code)

private static volatile ManualResetEvent[] resetEvents = new ManualResetEvent[NumThreads]; 
public void UpdateServerData() 
{ 
    for (int i = 0; i < NumThreads ; i++) 
     { 
      resetEvents[i] = new ManualResetEvent(false); 
      ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), (object) i); 

     } 
    WaitHandle.WaitAll(resetEvents); 
} 
private void DoWork(object param) 
{ 
//do some random work 
resetEvents[(int)param].Set(); 
} 

EDIT: J'ai essayé d'insérer un System.Threading.Thread.MemoryBarrier(); après chaque .Set() cependant j'obtiens toujours une exception de référence nulle.

Answer 1

Quasiment je trouve la question était

for (int i = 0; i < NumThreads ; i++)  
{   
resetEvents[i] = new ManualResetEvent(false);   
ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), resetEvents[i]);  
} 

Au lieu de déclarer une nouvelle ManualResetEvent J'ai simplement appelé Reset(). Le problème semble avoir été que, bien que j'utiliserais MemoryBarrier ou des verrous, la mémoire physique ne serait pas encore mise à jour, donc elle pointerait sur null.

Answer 2

Vous ne pouvez pas utiliser le mot clé as pour convertir en int (puisque int n'est pas un type de référence). Utilisez (int)param à la place:

private void DoWork(object param) 
{ 
    //do some random work 
    resetEvents[(int)param].Set(); 
} 

Une autre approche que je me sens est plus propre est de passer la poignée d'attente à la méthode à la place:

public void UpdateServerData() 
{ 
    for (int i = 0; i < NumThreads ; i++) 
    { 
     resetEvents[i] = new ManualResetEvent(false); 
     ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), resetEvents[i]); 
    } 
    WaitHandle.WaitAll(resetEvents); 
} 
private void DoWork(object param) 
{ 
    //do some random work 
    (param as ManualResetEvent).Set(); 
} 

De cette façon, la méthode de travail n'a aucune connaissance sur la façon dont la poignée d'attente est géré à l'extérieur; et il ne peut pas non plus atteindre les poignées d'attente pour d'autres threads par erreur.

Answer 3

volatile ManualResetEvent[] ne signifie pas que l'accès à éléments de tableau suit la sémantique volatile. Seul l'accès à la variable contenant la référence au tableau sera volatile. Essayez d'insérer une barrière de mémoire après avoir affecté l'élément de tableau, ou en utilisant Thread.VolatileWrite pour les définir, par ex.

Thread.VolatileWrite (ref resetEvents[i], new ManualResetEvent (false)) ;