Pasar varios parámetros a varios subprocesos en C #

1. Método 1: Usar el delegado ParameterizedThreadStart
Si un delegado ParameterizedThreadStart, la entrada del hilo debe tener un tipo de parámetros de objeto y el tipo de retorno es void
Ver el código
usando el Sistema,
usando el System.Threading;

espacio de nombres ThreadWithParameters
{
class Program
{
static void Main (string [] args)
{
string hello = "hola mundo";

         //这里也可简写成Thread thread = new Thread(ThreadMainWithParameters);
         //但是为了让大家知道这里用的是ParameterizedThreadStart委托，就没有简写了
         Thread thread = new Thread(new ParameterizedThreadStart(ThreadMainWithParameters));
         thread.Start(hello);

         Console.Read();
     }

     static void ThreadMainWithParameters(object obj)
     {
         string str = obj as string;
         if(!string.IsNullOrEmpty(str))
             Console.WriteLine("Running in a thread,received: {0}", str);
     }
 }

} El
código anterior solo puede pasar un parámetro. Si a veces pasamos varios parámetros al hilo, el uso de esa forma tendrá limitaciones (si se usa una clase como un objeto para pasar parámetros, entonces se necesita crear otra clase, lo cual también es un poco problemático)
Si usamos este método, debemos prestar mucha atención a que los parámetros en el método ThreadMainWithParameters deben ser del tipo de objeto y debemos realizar la conversión de tipos. No se recomienda este método.
2. Segunda forma: cree una
definición de clase personalizada de una clase, que defina los campos requeridos en el método de la definición de clase de subproceso principal de un método de instancia, ver ejemplo práctico.
Ver código
usando System;
using System.Threading;

espacio de nombres ThreadWithParameters
{
clase pública MyThread
{
datos de cadena privada;

     public MyThread(string data)
     {
         this.data = data;
     }

     public void ThreadMain()
     {
         Console.WriteLine("Running in a thread,data: {0}", data);
     }
 }

 class Program
 {
     static void Main(string[] args)
     {
         MyThread myThread = new MyThread("hello world");

         Thread thread = new Thread(myThread.ThreadMain);
         thread.Start();

         Console.Read();
     }
 }

}
Este método también es un poco engorroso, y no es en lo que quiero enfocarme. Si es necesario, puedo usarlo yo mismo.
3. Tres formas: utilizando expresión lambda
para expresiones lambda con las que no esté familiarizado puede ver la documentación en Microsoft MSDN. Se supone que está familiarizado aquí. Debido a que la mayoría de las veces cuando usamos delegados, generalmente podemos usar expresiones lambda.
Ver código
usando System;
using System.Threading;

espacio de nombres ThreadWithParameters
{
class Program
{
static void Main (string [] args)
{
string hello = "hola mundo";

         //如果写成Thread thread = new Thread(ThreadMainWithParameters(hello));这种形式，编译时就会报错
         Thread thread = new Thread(() => ThreadMainWithParameters(hello));
         thread.Start();

         Console.Read();
     }

     static void ThreadMainWithParameters(string str)
     {
          Console.WriteLine("Running in a thread,received: {0}", str);
     }
 }

}
Este método tres se puede usar como método recomendado, el código es simple y conveniente para nosotros. El tercer método anterior habla de expresiones lambda. Dado que se pueden usar expresiones lambda, también podemos usar delegate. La discusión principal a continuación es utilizar este método.
4. Método 3: usar delegado para delegar
Multhd = new Thread [ThreadCount];
thread_Separate_baseCount = C_num / ThreadCount; // El número de terminales por hilo
listViewEx2.Items.Clear ();
for (int j = 0; j <ThreadCount; j ++ )
{
if (j == ThreadCount-1) // El último hilo
{
Multhd [j] = new Thread (delegate () {Run2 (j * thread_Separate_baseCount, C_num-1);});
}
else // Otros hilos
{
Multhd [j] = new Thread (delegate () {Run2 (j * thread_Separate_baseCount, (j + 1) * thread_Separate_baseCount-1);});
}
} El
código anterior Run (arg1, arg2 ....., argn) es nuestro yo El método definido, en este método, podemos configurar cualquier número de parámetros, puede considerarse simple.
El código anterior puede ejecutarse perfectamente, y no habrá errores ni cosas por el estilo, pero la situación real de ejecución me ha sorprendido.Cuando se crea un hilo con un bucle for, no habrá problemas para cerrar y reiniciar el hilo. Debido a que es solo un hilo, puede que no haya nada de malo. Pero cuando hay dos o más, cierre y vuelva a abrir el hilo (necesito seguir cerrando y abriendo el terminal), el programa no reportará un error, el depurador no tendrá ningún problema y la computadora a veces se apagará sin previo aviso, cuando estemos haciendo cosas. Apagar sin previo aviso es un problema fatal y nadie quiere hacerlo. Pensé que era accidental, y el resultado fue el mismo después de repetido muchas veces, y la inevitabilidad accidental también debe existir.
¿Por qué un hilo está bien? Cuando se ejecutan varios hilos, ¿los hilos de arriba apuntan a la misma dirección del delegado, lo que provoca el cierre sin previo aviso? Estos están esperando que los verifiquemos.
Lugar de reimpresión: https://www.cnblogs.com/lvdongjie/p/5416883.html