Cómo trabajar con subprocesos en C #

Un hilo es la unidad de ejecución más pequeña dentro de un proceso. El subproceso múltiple es la capacidad de tener varios subprocesos en la memoria en un momento dado y cambiar entre ellos para manejar múltiples operaciones al mismo tiempo. El .Net Framework de Microsoft proporciona un excelente soporte para trabajar con subprocesos.

Programar subprocesos en C #

Para trabajar con subprocesos, debe incluir el espacio de nombres System.Threading en su aplicación. Para crear un nuevo hilo, debe aprovechar el delegado de ThreadStart y pasar la referencia a un método que debería ejecutarse en el hilo. Tenga en cuenta que un delegado es un puntero de función de tipo seguro. El siguiente fragmento de código muestra cómo puede crear un nuevo objeto de hilo usando este delegado.

 Thread t = new Thread (nuevo ThreadStart (MyThreadMethod)); 

Para iniciar el hilo recién creado, debe llamar al método Start en el objeto hilo que ha creado. La siguiente lista de códigos ilustra esto. Tenga en cuenta que el método de hilo MyThreadMethod se ejecuta en el nuevo hilo (llamado hilo de trabajo) que se ha creado.

 vacío estático Main ()

        {

            Thread t = new Thread (nuevo ThreadStart (MyThreadMethod));

            t.Start ();           

            Console.Read ();

        }

        estático vacío MyThreadMethod ()

        {

            Console.WriteLine ("¡Hola mundo!");

        }

Mostrar estados de subprocesos en C #

Un subproceso en la memoria puede estar en diferentes estados: abortado, en segundo plano, en ejecución, detenido, suspendido, sin iniciar, etc. Los estados del subproceso se definen en la enumeración ThreadState disponible en el espacio de nombres System.Threading. A menos que se llame al método Start en un hilo, el hilo está en el estado No iniciado. Cuando se invoca el método Start en la instancia del subproceso, el estado del subproceso cambia de No iniciado a En ejecución.

El siguiente fragmento de código muestra cómo puede mostrar el estado de un hilo en la consola.

 Thread t = new Thread (nuevo ThreadStart (MyThreadMethod));

t.Start ();

Console.WriteLine (“El estado del hilo es:“ + t.ThreadState.ToString ());

Controlar los subprocesos en primer plano y en segundo plano en C #

Los subprocesos pueden ejecutarse en primer plano o en segundo plano. Los subprocesos que crea explícitamente son subprocesos en primer plano. Una de las principales diferencias entre un subproceso en primer plano y un subproceso en segundo plano es que su aplicación solo está activa mientras se estén ejecutando uno o más subprocesos en primer plano. En esencia, los subprocesos en primer plano evitan que la aplicación finalice. Por el contrario, los subprocesos en segundo plano no mantienen vivo el entorno de Common Language Runtime.

Puede establecer el estado de fondo de un hilo usando la propiedad IsBackground. Aquí hay un ejemplo de código que muestra cómo se puede lograr.

 vacío estático Main ()

        {

            Thread t = new Thread (nuevo ThreadStart (MyThreadMethod));

            t.Start ();

            t.IsBackground = verdadero;

            Console.WriteLine (“El estado de fondo del hilo es:“ + t.IsBackground.ToString ());

            Console.Read ();

        }

Puede suspender o reanudar un hilo invocando los métodos Suspend () y Resume () en el objeto hilo. Tenga en cuenta que solo puede reanudar un hilo que suspendió anteriormente mediante una llamada al método Suspend ().

 Thread t = new Thread (nuevo ThreadStart (MyThreadMethod));

t.Start ();

t.Suspender (); // Suspende el hilo recién creado

t.Resume (); // Reanuda el hilo suspendido

Sin embargo, debe tenerse en cuenta que los métodos Thread.Suspend () y Thread.Resume () han quedado obsoletos. En su lugar, debe utilizar los métodos AutoResetEvent y EventWaitHandle para sincronizar actividades que involucren subprocesos.

Establecer prioridad de subproceso en C #

Puede controlar la prioridad de un subproceso para determinar la proporción relativa de tiempo de procesador que obtendrá un subproceso en comparación con los otros subprocesos que residen en la memoria. La prioridad de subproceso se define en la enumeración ThreadPriority. Los valores posibles incluyen: Lowest, BelowNormal, Normal, AboveNormal y Highest. El siguiente fragmento de código ilustra cómo puede establecer las prioridades de subproceso de dos subprocesos mediante la propiedad Prioridad del objeto de subproceso.

 vacío estático Main ()

        {

            Thread thread1 = new Thread (new ThreadStart (Method1));

            Thread thread2 = new Thread (nuevo ThreadStart (Method2));

            thread1.Priority = ThreadPriority.Highest;

            thread2.Priority = ThreadPriority.Lowest;

            thread2.Start ();

            thread1.Start ();

            Console.Read ();

        }

        Método de vacío estático1 ()

        {

            para (int i = 0; i <10; i ++)

            {

                Console.WriteLine ("Primer hilo:" + i);

            }

        }

        Método de vacío estático 2 ()

        {

            para (int i = 0; i <10; i ++)

            {

                Console.WriteLine ("Segundo hilo:" + i);

            }

        }

Cuando ejecute el fragmento de código anterior, verá que el primer subproceso completa su ejecución antes que el segundo subproceso aunque el segundo subproceso se inició antes que el primer subproceso en el método Main.

Los hilos son caros. Consumen muchos recursos de su sistema para la inicialización, el cambio de contextos y la liberación de los recursos que consumen. En consecuencia, el subproceso múltiple debe usarse con prudencia y solo cuando sea necesario. Cuando aprovecha el subproceso múltiple, siempre es aconsejable aprovechar los grupos de subprocesos para crear y administrar subprocesos a pedido y mejorar la capacidad de respuesta de su aplicación.