¿Cómo puedo verificar que mi código multiproceso se esté ejecutando realmente en varios hilos?

Question

Mi programa tiene una lista de 200k archivos. Tengo que importar cada uno a la base de datos. Me lleva mucho tiempo, así que comencé a investigar acerca de los multihilos como un medio para acelerar el proceso de importación. Finalmente llegué a una implementación, pero no estoy seguro de que realmente funcione.

Después de usar Workaround for the WaitHandle.WaitAll 64 handle limit? como una muestra de mi código C# He ocurrió:

int threadCount = 0;  

for (int i = 0; i < this.Total; i++) 
{ 
     Finished = new ManualResetEvent(false); 
     threadCount = this.ThreadCount; 
     Interlocked.Increment(ref threadCount); 

     FileHandler fh = new FileHandler(finished, sorted[i], this.PicturesFeatures, this.Outcome, this.SiteIds, this.LastId, this.Order, this.ThreadCount); 
     Console.Write(i + " "); 
     ThreadPool.QueueUserWorkItem(new WaitCallback(HandleFile), fh); 
     Console.Write(i + " "); 
     Finished.WaitOne(); 
} 

Y HandleFile() sale como:

private void HandleFile(object s) 
    {   
     try 
     { 
      //code   
     } 
     finally 
     { 
      if (Interlocked.Decrement(ref threadCount) == 0) 
      { 
       Finished.Set(); 
      } 
     } 
    } 

he puesto esos Console.Write pensando que si un proceso es más largo terminaría más tarde que otro ("0 0 1 2 2 1 3 3 ..."), pero siempre está en orden ("0 0 1 1 2 2 3 3 4 4 ... ")

Answer 1

Su salida es de esperar. Está escribiendo la salida en el hilo principal, la función QueueUserWorkItem no bloquea, registra su función HandleFile para ser ejecutada en un hilo separado. Por lo tanto, independientemente de cuánto tiempo tarden los elementos de trabajo, sus impresiones se realizarán en el orden esperado, ya que todas provienen del hilo principal.

Además, no obtiene el beneficio del paralelismo con este código porque está esperando cada elemento que envíe. Básicamente, estás diciendo que no enviaré mi próximo artículo de trabajo hasta que el último haya terminado. Esta es solo una forma más complicada de escribir un código serial normal. Para introducir el paralelismo, debe agregar varios elementos a la cola sin tener que esperar entre ellos.

Answer 2

En primer lugar, no se garantiza que los hilos generados a partir de una aplicación multiproceso terminen en un orden en particular. Es posible que haya comenzado primero un hilo, pero puede que no necesariamente termine primero.

Dicho esto, se puede utilizar Process Explorer: http://technet.microsoft.com/en-us/sysinternals/bb896653.aspx

Process Explorer le mostrará que se enrosca su programa es el desove.

Answer 3

Interrumpa la ejecución mientras se está ejecutando (ctrl + alt + break) y luego eche un vistazo a la ventana de subprocesos. (Depurar -> Windows -> Hilos).

Answer 4

Tiene un par de problemas.

• Los elementos de trabajo se serializarán eficazmente ya que está esperando a que se complete cada uno antes de comenzar el siguiente.
• Las llamadas Console.WriteLine están en el hilo principal, por lo que es natural que informen i como incrementos en orden.

Aquí está el patrón canónico para hacer esto correctamente.

int count = TOTAL_ITERATIONS; 
var finished = new ManualResetEvent(false); 
for (int i = 0; i < TOTAL_ITERATIONS; i++) 
{ 
    int captured = i; // Use this for variable capturing in the anonymous method. 
    ThreadPool.QueueUserWorkItem(
    delegate(object state) 
    { 
     try 
     { 
     Console.WriteLine(captured.ToString()); 
     // Your task goes here. 
     // Refer to 'captured' instead of 'i' if you need the loop variable. 
     Console.WriteLine(captured.ToString()); 
     } 
     finally 
     { 
     if (Interlocked.Decrement(ref count) == 0) 
     { 
      finished.Set(); 
     } 
     } 
    }); 
} 
finished.WaitOne(); 

Editar: Para demostrar fácilmente que varios subprocesos se invocan uso el siguiente código.

public static void Main() 
{ 
    const int WORK_ITEMS = 100; 
    int count = WORK_ITEMS; 
    var finished = new ManualResetEvent(false); 
    Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString() + ":Begin queuing..."); 
    for (int i = 0; i < WORK_ITEMS; i++) 
    { 
     int captured = i; // Use this for variable capturing in the anonymous method. 
     ThreadPool.QueueUserWorkItem(
      delegate(object state) 
      { 
       try 
       { 
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString() + ":" + captured.ToString()); 
        for (int j = 0; j < 100; j++) Thread.Sleep(1); 
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString() + ":" + captured.ToString()); 
       } 
       finally 
       { 
        if (Interlocked.Decrement(ref count) == 0) 
        { 
         finished.Set(); 
        } 
       } 
      }); 
    } 
    Console.WriteLine(Thread.CurrentThread.ManagedThreadId.ToString() + ":...end queueing"); 
    finished.WaitOne(); 
    Console.ReadLine(); 
} 

Answer 5

La información que está produciendo proviene del mismo hilo (el que ejecuta el ciclo). Si desea ver evidencia de múltiples hilos, puede dar como resultado el nombre del hilo o algún otro valor de su función HandleFile.