Introducción a Multithreading en C #

Para comprender el subprocesamiento múltiple en c #, primero comprendamos qué es un subproceso.

  • Un hilo es un proceso ligero.
  • Es una ruta de ejecución de un programa.
  • Es la unidad de procesamiento más pequeña en un sistema operativo.
  • Por lo tanto, un proceso puede tener múltiples hilos.

Entonces, el subprocesamiento múltiple es un proceso que contiene múltiples subprocesos en el que cada subproceso realiza una actividad diferente. Ahorra tiempo porque diferentes tareas están siendo ejecutadas al mismo tiempo por diferentes hilos. Aumenta la utilización de la CPU y aumenta la eficiencia de una aplicación. Esto funciona en el concepto de tiempo compartido.

Sintaxis con Explicación

Thread first_thread_name = new Thread(new ThreadStart(method_to_be_executed1));
Thread second_thread_name = new Thread(new ThreadStart(method_to_be_executed2));
first_thread_name.Start();
second_thread_name.Start();

Para crear un hilo, necesitamos crear un objeto de clase Thread. El constructor de la clase Thread toma referencia de ThreadStart. ThreadStart es un delegado que representa un método que debe ejecutarse cuando el hilo comienza a ejecutarse.

El hilo comienza la ejecución cuando se llama al método Start ().

Podemos crear un hilo sin usar el delegado ThreadStart como se muestra en la siguiente sintaxis:

Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();

Crear múltiples hilos en C #

Para crear subprocesos, necesitamos importar el sistema. Podemos crear e inicializar hilos usando la clase Thread.

Ejemplo con clase de subproceso

using System;
using System.Threading;
public class MultiThreadingDemo
(
public static void Method1()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
public static void Main()
(
// Creating and initializing threads
Thread thread1 = new Thread(Method1);
Thread thread2 = new Thread(Method2);
//beginning thread execution
thread1.Start();
thread2.Start();
)
)

Salida:

Ejemplo usando el delegado ThreadStart

using System;
using System.Threading;
public class MultiThreading
(
public static void Method1()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method1 : (0)", i);
)
)
public static void Method2()
(
for (int i = 1; i <= 5; i++)
(
Console.WriteLine("Method2 : (0)", i);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Thread thread1 = new Thread(new ThreadStart(MultiThreading.Method1 ) );
Thread thread2 = new Thread(new ThreadStart(MultiThreading.Method2 ) );
thread1.Start();
thread2.Start();
)
)

Salida:

Nota: No es necesario que los métodos utilizados en el subprocesamiento múltiple sean estáticos, como en los dos ejemplos anteriores, ambos métodos, es decir, el Método 1 y el Método 2 son estáticos. Estos métodos pueden ser no estáticos y, en ese caso, primero debemos crear un objeto de la clase que contenga métodos y luego poder acceder a los métodos utilizando el objeto.

En C #, un programa siempre contiene un subproceso, es decir, Subproceso principal. Cuando creamos otros subprocesos, se convierte en un programa de subprocesos múltiples y en C # de subprocesos múltiples, hay dos tipos de subprocesos:

  • Subproceso en primer plano : este subproceso sigue ejecutándose hasta que finaliza su trabajo, incluso si el subproceso principal termina.
  • Subproceso de fondo : cuando finaliza el subproceso principal, el subproceso de fondo también deja de ejecutarse y termina con el subproceso principal.

Métodos con ejemplos

Veamos algunos métodos comúnmente utilizados de la clase Thread con ejemplos.

  • Suspender (): se utiliza para pausar la ejecución del subproceso actual durante un período de tiempo específico, de modo que otros subprocesos comiencen la ejecución.

Ejemplo:

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 1; i <= 10; i++)
(
Console.WriteLine(i);
//suspending execution of current thread for 100 milliseconds
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
thread1.Start();
thread2.Start();
)
)

Salida:

La salida muestra que ambos hilos se ejecutan en paralelo.

  • Abortar (): Se usa para terminar el hilo o podemos decir que se usa para detener la ejecución del hilo permanentemente.

Ejemplo

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 10; i++)
(
Console.WriteLine(i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Console.WriteLine("Threads start execution");
thread1.Start();
thread2.Start();
try
(
//terminating execution of thread using Abort()
thread1.Abort();
thread2.Abort();
Console.WriteLine("Threads execution terminated");
)
catch (ThreadAbortException threadAbortException)
(
Console.WriteLine(threadAbortException.ToString());
)
)
)

Salida:

  • Join (): se utiliza para hacer que todos los hilos de llamada esperen hasta que el hilo actual complete su ejecución y finalice.

Ejemplo:

using System;
using System.Threading;
public class Multithreading
(
public void Display()
(
for (int i = 0; i < 5; i++)
(
Thread thread = Thread.CurrentThread;
Console.WriteLine(thread.Name +" : "+i);
Thread.Sleep(100);
)
)
)
public class MultithreadingDemo
(
public static void Main()
(
Multithreading multithreading = new Multithreading();
Thread thread1 = new Thread(new ThreadStart(multithreading.Display));
Thread thread2 = new Thread(new ThreadStart(multithreading.Display));
Thread thread3 = new Thread(new ThreadStart(multithreading.Display));
//Assigning names to threads using Name property
thread1.Name = "Thread1";
thread2.Name = "Thread2";
thread3.Name = "Thread3";
thread1.Start();
//Making Thread2 and Thread3 wait until Thread1 completes execution
thread1.Join();
thread2.Start();
thread3.Start();
)
)

Salida:

Ventajas de Multithreading en C #

  1. Ayuda a mantener una interfaz de usuario receptiva: a veces tenemos un método que consume mucho tiempo en nuestra aplicación. En ese caso, si hacemos que nuestra aplicación sea multiproceso, entonces otro subproceso se responsabiliza de la ejecución de ese método, mientras que el subproceso principal puede centrarse en la capacidad de respuesta de la aplicación. Por lo tanto, no congelará nuestra aplicación dando una respuesta adecuada al usuario a tiempo.
  2. Aumenta el rendimiento de la aplicación: si tenemos tantos subprocesos como núcleos de procesador, cada subproceso se ejecutará de forma independiente y aumentará el número de cálculos por segundo.
  3. Los subprocesos minimizan el uso de los recursos del sistema, ya que comparten el mismo espacio de direcciones.
  4. Hace que el código sea más rápido y más simple al mismo tiempo.

Conclusión: Multithreading en C #

La clase Thread proporciona muchas propiedades importantes como Prioridad, Nombre, IsAlive, fondo que podemos usar en nuestra aplicación de subprocesos múltiples. La sincronización de subprocesos es una técnica mediante la cual un subproceso puede acceder a un recurso durante un tiempo determinado sin la interrupción de otros subprocesos hasta que complete su tarea.

Artículos recomendados

Esta ha sido una guía para el subprocesamiento múltiple en C #. Aquí también discutimos su introducción, sintaxis, creación y ejemplos de subprocesos múltiples en c #. También puede consultar los siguientes artículos para obtener más información:

  1. Objetos en C #
  2. Destructor en C #
  3. Destructor en C #
  4. Herencia en C #
  5. Destructor en PHP | Ejemplos

Categoría:

Desarrollo de software