hilos que activan C#

Question

tengo este código en C#:

Thread t1 = new Thread(functionsActivations(3, 4000, 0, 4)); 
Thread t2 = new Thread(functionsActivations(3, 4000, 5, 9)); 
t1.start(); 
t2.Start(); 
Thread t3 = new Thread(functionsActivations(4, 4000, 0, 4)); 
Thread t4 = new Thread(functionsActivations(4, 4000, 5, 9)); 

No está funcionando. ¿Cómo puedo decirle que llame al método que le di? En segundo lugar, quiero que t3 y t4 se activen después de que t1 y t2 terminen de ejecutarse. ¿Cómo puedo hacer eso? Tercero, quiero que t1 y t2 no bloqueen (para que t2 no tenga que esperar hasta que termine t1). ¿Es lo que hice correcto?

Answer 1

"No funciona" no es un conjunto muy claro de síntomas. ¿Qué estás observando?

EDITAR: Bien, ahora que ha dicho lo que es el error del compilador, es mucho más fácil de diagnosticar. Actualmente está llamando a un método e intentando usar el resultado como una tarea para que se ejecute el subproceso. Asumiendo que realidad quieren hacer que el método de llamada cuando se inicia el hilo, usted quiere algo como esto:

C# 2:

Thread t1 = new Thread(delegate() { functionsActivations(3, 4000, 0, 4); }); 

C# 3:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4)); 

Un altnerative a tener expresiones lambda por todo el lugar sería escribir un método de utilidad:

private static Action DeferFunctionActivations(int a, int b, int c, int d) 
{ 
    return() => functionsActivations(a, b, d, d); 
} 

Posteriormente, se podría utilizar:

Thread t1 = new Thread(DeferFunctionActivations(3, 4000, 0, 4)); 

etc.

Para el resto del post voy a suponer C# 3.

Además, debe haber t1.start()t1.Start() - C# entre mayúsculas y minúsculas.

Para responder a su punto final, t1 y t2 son actualmente independientes: no se bloquearán entre sí a menos que tenga sincronización en alguna parte del código que están ejecutando.

Si sólo desea t3 y t4 empezar cuando t1 y t2 han terminado, se puede usar Thread.Join:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4)); 
Thread t2 = new Thread(() => functionsActivations(3, 4000, 5, 9)); 
t1.Start(); 
t2.Start(); 
t1.Join(); 
t2.Join(); 
Thread t3 = new Thread(() => functionsActivations(4, 4000, 0, 4)); 
Thread t4 = new Thread(() => functionsActivations(4, 4000, 5, 9)); 
t3.Start(); 
t4.Start(); 

Tenga en cuenta que esto significa que este hilo esperará hasta t1 y t2 han terminado, también. Si eso no es lo suficientemente bueno para ti, hay varias opciones, pero básicamente querrás algo más para esperar asíncronamente a que t1 y t2 se completen. Por ejemplo, usted podría atar un hilo extra para hacer eso:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4)); 
Thread t2 = new Thread(() => functionsActivations(3, 4000, 5, 9)); 
t1.Start(); 
t2.Start(); 
Thread t3 = new Thread(() => functionsActivations(4, 4000, 0, 4)); 
Thread t4 = new Thread(() => functionsActivations(4, 4000, 5, 9)); 
Thread t5 = new Thread(() => 
{ 
    t1.Join(); 
    t2.Join(); 
    t3.Start(); 
    t4.Start(); 
}); 
t5.Start(); 

Algo repulsivo, pero debería funcionar.

¿Eres capaz de utilizar .NET 4.0? Si es así, el marco de Extensiones Paralelas hace que esto sea mucho más fácil.