Subprocesamiento múltiple en C#: beneficios, conceptos básicos y mejores prácticas

¿Qué es la programación multihilo?

Multithreading es un concepto fundamental en la ingeniería de software. En C#, la programación multiproceso es esencial para los desarrolladores de software que trabajan con .NET Framework. Los desarrolladores utilizan ampliamente subprocesos múltiples en C# , ya que les permite crear aplicaciones complejas y receptivas de manera eficiente.

Este blog proporciona una descripción general de los subprocesos múltiples de C# y, al mismo tiempo, analiza cómo los programadores pueden crear y administrar subprocesos fácilmente. También incluye los beneficios de usar subprocesos múltiples y los diferentes modelos de subprocesos disponibles en C#.

Beneficios y ventajas de la programación multiproceso

Cuando se ejecutan simultáneamente, los subprocesos múltiples mejoran la eficacia de las aplicaciones. Los beneficios más comunes del subproceso de C# incluyen lo siguiente:

• Rendimiento mejorado de la aplicación: con la ayuda de subprocesos múltiples, las aplicaciones se ejecutan más rápido con múltiples tareas ejecutándose en el mismo espacio.En su totalidad, reduce el tiempo de ejecución y da paso a múltiples tareas.
• Mayor rendimiento: la multitarea en C# mejora el rendimiento de las aplicaciones.Cuando dos subprocesos diferentes se ejecutan simultáneamente, puede ahorrar tiempo y recursos.
• Capacidad de respuesta mejorada: con la ayuda de subprocesos múltiples, un usuario puede acceder al front-end de la aplicación mientras el programa se ejecuta en segundo plano.
• Mayor utilización de recursos: los subprocesos múltiples permiten a los usuarios acceder a los recursos del sistema de manera más eficiente.Por ejemplo, los subprocesos pueden compartir recursos como archivos, memoria y dispositivos de E/S, allanando el camino hacia la eficiencia.
• Programación más accesible: los subprocesos múltiples permiten una programación más sencilla, ya que los usuarios pueden escribir subprocesos de forma independiente.También permite a los usuarios depurar y probar aplicaciones de forma aislada.
• Comunicación optimizada: la sincronización de subprocesos permite una mejor comunicación de proceso a proceso.Se puede utilizar para una comunicación más accesible entre subprocesos.

En primer lugar, afecta a objetos individuales que se pueden sincronizar. En segundo lugar, se puede utilizar con las clases System.Threading e Interlocked.

Conceptos básicos de subprocesamiento múltiple en C#

Multithreading permite a los usuarios realizar múltiples tareas simultáneamente con la ayuda de múltiples núcleos de procesador. Estos son los conceptos básicos utilizados en subprocesos múltiples:

• Subprocesos: los subprocesos son las unidades básicas en subprocesos múltiples que ayudan a ejecutar un proceso.Estas son rutas de ejecución dentro de un programa dado que pueden ejecutarse simultáneamente junto con otros subprocesos.

En C#, podemos encontrar dos tipos de subprocesos, a saber, subprocesos de primer plano y de fondo. La clase de subproceso promedio incluye un nombre, prioridad, isAlive, ThreadState, Start(), Suspend(), Resume() y Join().

• Grupo de subprocesos: un grupo de subprocesos es un subproceso que ayuda a ejecutar tareas.Permite que el sistema operativo reutilice los hilos existentes y minimiza el riesgo de posibles gastos generales.
• Sincronización: la sincronización pasa por alto el acceso a otros subprocesos para múltiples operaciones.Es un proceso esencial para mantener la integridad de los datos y evitar gastos generales.
• Interbloqueo: un interbloqueo es un error que ocurre cuando dos subprocesos comparten recursos e intentan continuar sin tener éxito.Puede hacer que el sistema se congele o incluso provocar un tiempo de espera.
• Programación asíncrona: la programación asíncrona permite ejecutar múltiples tareas en segundo plano y permite que el subproceso principal se ejecute sin interrupción.Allana el camino para múltiples interfaces de usuario receptivas, mejorando el rendimiento de la aplicación.

Creación y ejecución de subprocesos

Crear y ejecutar puede ser más fácil con estos ejemplos. A continuación se muestra un ejemplo de subprocesos múltiples en C# :

utilizando el sistema;

utilizando System.Threading;

programa de clase {

vacío estático principal () {

int índicetrabajador = 0;

Thread workerThread = new Thread(new ThreadStart(Worker));

subprocesotrabajador.Inicio();

for (int índiceprincipal = 1; índiceprincipal <= 10; índiceprincipal++) {

Console.WriteLine(“Subproceso principal: {0}”, mainIndex);

Subproceso.Sueño(200);

}

subprocesotrabajador.Join();

}

Trabajador vacío estático () {

for (int índicetrabajador = 1; índicetrabajador <= 10; índicetrabajador++) {

Console.WriteLine(“Subproceso de trabajo: {0}”, workerIndex * 2);

Subproceso.Sueño(200);

}

}

}

Producción:

Hilo principal: 1

Subproceso de trabajo: 2

Hilo principal: 2

Hilo de trabajo: 4

Hilo principal: 3

Hilo de trabajo: 6

Hilo principal: 4

Hilo de trabajo: 8

Hilo principal: 5

Hilo de trabajo: 10

Hilo principal: 6

Hilo de trabajo: 12

Hilo principal: 7

Hilo de trabajo: 14

Hilo principal: 8

Subproceso de trabajo: 16

Hilo principal: 9

Subproceso de trabajo: 18

Hilo principal: 10

Subproceso de trabajo: 20

Explicación: en esta salida, ambos subprocesos funcionan simultáneamente para imprimir los números del 1 al 10 y del 2 al 20, este último duplicado desde el índice del bucle.En este ejemplo, se ha utilizado el método de suspensión de subprocesos de C# (Thread.Sleep).

De la misma manera, veremos otro ejemplo de subproceso de C# utilizando el subproceso de primer plano:

utilizando el sistema;

utilizando System.Threading;

programa de clase {

vacío estático principal () {

Subproceso myThread = nuevo Subproceso (Trabajador);

miSubproceso.Inicio();

Console.WriteLine(“Subproceso principal: Iniciado”);

para (int i = 1; i <= 5; i++) {

Console.WriteLine(“Subproceso principal: Recuento {0}”, i);

Subproceso.Sueño(500);

}

Console.WriteLine(“Subproceso principal: Finalizado”);

}

Trabajador vacío estático () {

para (en j = 1; j <= 5; j++) {

Console.WriteLine(“Subproceso de trabajo: Recuento {0}”, j * 3);

Subproceso.Sueño(750);

}

Console.WriteLine("Subproceso de trabajo: Finalizado");

}

}

Producción:

Hilo principal: Comenzado

Subproceso de trabajo: cuenta 3

Hilo principal: Cuenta 1

Subproceso de trabajo: cuenta 6

Hilo principal: Cuenta 2

Subproceso de trabajo: cuenta 9

Hilo principal: Cuenta 3

Subproceso de trabajo: cuenta 12

Hilo principal: Cuenta 4

Subproceso de trabajo: cuenta 15

Hilo principal: Cuenta 5

Subproceso de trabajo: terminado

Hilo principal: Terminado

Explicación: Esta salida muestra cómo funcionan los dos subprocesos simultáneamente.Como los subprocesos principal y de fondo funcionan en paralelo, el subproceso principal imprime números del 1 al 5. El subproceso de trabajo imprime múltiplos de 3 a 15.

Consulte los cursos de desarrollo de software en upGrad para mejorar sus habilidades.

Lea nuestros artículos populares relacionados con el desarrollo de software

Sincronización de subprocesos

La sincronización de subprocesos implica la coordinación colectiva de múltiples subprocesos en un programa. Asegura que el programa se ejecute en un orden específico dando acceso a los recursos compartidos.

En C#, se realiza utilizando primitivas de sincronización como la palabra clave lock, los objetos de sincronización y la clase Interlocked.

A continuación se muestra un ejemplo de sincronización de subprocesos de C# :

Sistema de uso;

Uso de System.Threading;

clase TablePrinter

{

vacío público PrintTable()

{

bloquear (esto)

{

para (int i = 3; i <= 8; i++)

{

Subproceso.Sueño(200);

Consola.WriteLine(i*5);

}

}

}

}

programa de clase

{

public static void Principal (cadena [] args)

{

TablePrinter tp = new TablePrinter();

Subproceso t1 = nuevo Subproceso (nuevo ThreadStart (tp.PrintTable));

Subproceso t2 = nuevo Subproceso (nuevo ThreadStart (tp.PrintTable));

t1.Inicio();

t2.Inicio();

}

}

Producción:

15

20

25

30

35

40

45

50

55

60

Explore nuestros cursos gratuitos de desarrollo de software

interbloqueos

Los interbloqueos en subprocesos múltiples ocurren cuando al menos dos o más subprocesos dependen de un conjunto de recursos. Cuando un subproceso se superpone a la ruta a la ayuda mientras que el otro intenta hacer lo mismo, se convierte en un punto muerto.

Por ejemplo, si el Subproceso A tiene un bloqueo en el Recurso 1 y está esperando para acceder al Recurso 2 mientras el Subproceso B espera el Recurso 1, puede resultar en un interbloqueo.

A continuación se muestra un ejemplo:

utilizando el sistema;

utilizando System.Threading;

espacio de nombres deadlockincsharp

{

Ejemplo de clase pública

{

objeto estático de solo lectura firstLock = new object();

objeto estático de solo lectura secondLock = new object();

ThreadJob vacío estático ()

{

Console.WriteLine(“\t\t\t\tLocking firstLock”);

bloquear (primer bloqueo)

{

Console.WriteLine(“\t\t\t\tLocked firstLock”);

Subproceso.Sueño(1500);

Console.WriteLine(“\t\t\t\tLocking secondLock”);

bloqueo (segundo bloqueo)

{

Console.WriteLine(“\t\t\t\tLocked secondLock”);

}

Console.WriteLine(“\t\t\t\tReleased secondLock”);

}

Console.WriteLine(“\t\t\t\tPrimer bloqueo liberado”);

}

vacío estático principal ()

{

nuevo hilo (nuevo ThreadStart (ThreadJob)). Inicio ();

Subproceso.Sueño(1000);

Console.WriteLine(“Bloqueando segundoBloqueo”);

bloqueo (segundo bloqueo)

{

Console.WriteLine(“Segundo bloqueo bloqueado”);

Console.WriteLine(“Bloqueando firstLock”);

bloquear (primer bloqueo)

{

Console.WriteLine(“Bloqueado primeroLock”);

}

Console.WriteLine(“Primer bloqueo liberado”);

}

Console.WriteLine("Segunda cerradura liberada");

Consola.Read();

}

}

}

Producción:

Segundo bloqueoBloqueo

Bloqueado segundoBloqueo

Bloquear primeroBloquear

Bloqueado primeroBloquear

Liberado primeroBloqueo

Segundo bloqueo liberado

Habilidades de desarrollo de software bajo demanda

Grupos de subprocesos

Los grupos de subprocesos ayudan a administrar varios subprocesos de ejecución en un entorno multiproceso en C#. Estos aseguran que todos los subprocesos tengan acceso a recursos controlados sin dar lugar a interbloqueos.

Un administrador de grupos de subprocesos se ocupa del grupo de subprocesos, donde es responsable de crear, destruir y programar subprocesos.

Aquí hay un ejemplo de un grupo de subprocesos que usa TPL (Biblioteca paralela de tareas):

utilizando el sistema;

utilizando System.Threading.Tasks;

programa de clase

{

vacío estático principal ()

{

Tarea<cadena> tarea = Task.Factory.StartNew<cadena>

(() => Cadena de Descarga(“http://www.ejemplo.com/”));

resultado de cadena = tarea.Resultado;

Console.WriteLine(resultado);

Consola.Read();

}

cadena estática DownloadString (cadena uri)

{

usando (var wc = nuevo System.Net.WebClient())

volver wc.DownloadString(uri);

}

Producción:

La salida depende de los contenidos disponibles en la página web. Este programa garantizará la descarga de contenidos de la página web desde la URL especificada. Luego los imprimirá.

Programación asincrónica con biblioteca paralela de tareas (TPL)

Task Parallel Library (TPL) es una herramienta poderosa para manejar APIS y tipos públicos. Maneja System.Threading y System.Threading.Tasks .

.NET Framework 4 ofrece API de lenguaje y nivel de marco para desarrolladores que buscan escribir código paralelo. Con la ayuda de TPL, la programación asíncrona permite que los programas se ejecuten sin bloquear el hilo principal.

Aquí hay un ejemplo de programación asíncrona con TPL:

Tarea<cadena> tarea = Tarea.Factory.StartNew<cadena>(() => {

devolver "resultado";

});

resultado de cadena = tarea.Resultado;

Tarea asincrónica Mi método () {

resultado de cadena = tarea en espera;

}

Consulte nuestroscursos de tecnología gratuitos para obtener una ventaja sobre la competencia.

Prácticas recomendadas para subprocesos múltiples en C#

Multithreading puede ahorrar tiempo en términos de rendimiento y multitarea. Para saber más sobre cómo funciona el subprocesamiento múltiple, puede optar por una Maestría en Ciencias en Ciencias de la Computación de LJMU .

Aquí hay algunas mejores prácticas para ayudar a los usuarios a ahorrar tiempo y registrar la mayor eficiencia.

• Utilice colecciones seguras para subprocesos: las colecciones concurrentes de .NET Framework proporcionan una versión segura para subprocesos de cada colección, lo que facilita que los subprocesos múltiples funcionen de manera eficiente.Estas colecciones incluyen listas y consultas, y diccionarios.
• Implemente la sincronización de subprocesos: los usuarios pueden implementar rápidamente bloqueos, monitores y semáforos debido a la naturaleza de las herramientas de subprocesos.
• Utilice la agrupación de subprocesos: la multiproceso puede ser más fácil y más eficiente para los sistemas, gracias a la gran mayoría de la agrupación de subprocesos realizada por los usuarios.Al mismo tiempo, los usuarios pueden usarlo para crear hilos automáticamente.
• Utilice el almacenamiento local de subprocesos: mientras practica subprocesos múltiples, garantice el acceso a un recurso en particular optimizando el almacenamiento local de subprocesos y ofreciendo acceso a múltiples subprocesos.
• Evite compartir estados mutables: los estados mutables compartidos solo generarán errores y condiciones de carrera, lo que puede ser complicado.Asegúrese de evitar estados mutables a toda costa.
• Use el modelo asincrónico: los métodos asincrónicos lo ayudan a implementar varias tareas en paralelo sin comenzarlas de nuevo o dejarlas en la cola.
• Evite interbloqueos: se pueden esperar interbloqueos cuando se ejecutan programas que utilizan subprocesos múltiples.Al escribir un programa, intente ejecutar un subproceso solo después de otro, evitando los puntos muertos.
• Use tokens de cancelación: los tokens de cancelación permiten que los subprocesos finalicen sin problemas y evitan los puntos muertos.

Explore nuestros cursos populares de ingeniería de software

Conclusión

Multithreading en C# sigue siendo un concepto esencial con su modelo de alta eficiencia en funcionamiento. Proporciona una forma flexible para que los programadores dividan la carga de trabajo de un programa en varias tareas que se ejecutan de forma simultánea e independiente.

Aunque los subprocesos múltiples pueden ser muy beneficiosos, pueden generar obstáculos potenciales si no se implementan con cuidado.

Dado que el presupuesto global para software empresarial supera los 856 000 millones de dólares entre 2009 y 2023, el desarrollo de software promete una carrera brillante para los desarrolladores.

¡ Solicite el Bootcamp de desarrollo de software Full Stack de upGrad ahora! Un curso de desarrollo de pila completa puede ser el trampolín para los desarrolladores que desean liberar su potencial en informática.