C# multiproceso – Part 1

La multitarea es la ejecución simultánea de múltiples tareas o procesos durante un cierto intervalo de tiempo. El sistema operativo Windows es un ejemplo de multitarea porque es capaz de ejecutar más de un proceso a la vez, como ejecutar Google Chrome, el Bloc de notas, el reproductor VLC, etc. al mismo tiempo. El sistema operativo utiliza un término conocido como proceso para ejecutar todas estas aplicaciones al mismo tiempo. Un proceso es una parte de un sistema operativo que es responsable de ejecutar una aplicación. Cada programa que se ejecuta en su sistema es un proceso y para ejecutar el código dentro de la aplicación, un proceso utiliza un término conocido como subproceso .
Un hilo es un proceso ligero, o en otras palabras, un hilo es una unidad que ejecuta el código bajo el programa. Entonces, cada programa tiene lógica y un hilo es responsable de ejecutar esta lógica. Cada programa por defecto lleva un subproceso para ejecutar la lógica del programa y el subproceso se conoce como subproceso principal , por lo que cada programa o aplicación es por defecto un modelo de subproceso único. Este modelo de un solo hilo tiene un inconveniente. El hilo único ejecuta todo el proceso presente en el programa de manera sincronizada, es decir, uno tras otro. Entonces, el segundo proceso espera hasta que el primer proceso complete su ejecución, consume más tiempo en el procesamiento.

Por ejemplo, tenemos una clase llamada Geek y esta clase contiene dos métodos diferentes, es decir , método1 , método2 . Ahora el subproceso principal es responsable de ejecutar todos estos métodos, por lo que el subproceso principal ejecuta todos estos métodos uno por uno.

Ejemplo:

// C# program to illustrate the 
// concept of single threaded model
using System;
using System.Threading;
  
public class Geek {
  
    // static method one
    public static void method1()
    {
  
        // It prints numbers from 0 to 10
        for (int I = 0; I <= 10; I++) {
  
            Console.WriteLine("Method1 is : {0}", I);
  
            // When the value of I is equal to 
            // 5 then this method sleeps for 
            // 6 seconds and after 6 seconds 
            // it resumes its working
            if (I == 5) {
                Thread.Sleep(6000);
            }
        }
    }
  
    // static method two
    public static void method2()
    {
  
        // It prints numbers from 0 to 10
        for (int J = 0; J <= 10; J++) {
  
            Console.WriteLine("Method2 is : {0}", J);
        }
    }
}
  
// Driver Class
public class GFG {
  
    // Main Method
    static public void Main()
    {
  
        // Calling static methods
        Geek.method1();
        Geek.method2();
    }
}

Producción:

Method1 is : 0
Method1 is : 1
Method1 is : 2
Method1 is : 3
Method1 is : 4
Method1 is : 5
Method1 is : 6
Method1 is : 7
Method1 is : 8
Method1 is : 9
Method1 is : 10
Method2 is : 0
Method2 is : 1
Method2 is : 2
Method2 is : 3
Method2 is : 4
Method2 is : 5
Method2 is : 6
Method2 is : 7
Method2 is : 8
Method2 is : 9
Method2 is : 10

Explicación: Aquí, en primer lugar, se ejecuta el método1 . En el método 1 , el ciclo for comienza desde 0 cuando el valor de i es igual a 5, luego el método entra en reposo durante 6 segundos y después de 6 segundos reanuda su proceso e imprime el valor restante. Hasta que el método 2 esté en estado de espera. El método 2 comienza a funcionar cuando el método 1 completa su tarea asignada. Entonces, para superar el inconveniente del modelo de un solo hilo, multithreading se introduce.

Los subprocesos múltiples son un proceso que contiene varios subprocesos dentro de un solo proceso. Aquí cada hilo realiza diferentes actividades. Por ejemplo, tenemos una clase y esta llamada contiene dos métodos diferentes, ahora usando subprocesos múltiples cada método es ejecutado por un subproceso separado. Entonces, la principal ventaja de los subprocesos múltiples es que funciona simultáneamente, lo que significa que se ejecutan varias tareas al mismo tiempo. Y también maximizar la utilización de la CPU porque los subprocesos múltiples funcionan con el concepto de tiempo compartido, lo que significa que cada subproceso toma su propio tiempo de ejecución y no afecta la ejecución de otro subproceso, este intervalo de tiempo lo proporciona el sistema operativo.

Ejemplo:

// C# program to illustrate the
// concept of multithreading
using System;
using System.Threading;
  
public class GFG {
  
    // static method one
    public static void method1()
    {
  
        // It prints numbers from 0 to 10
        for (int I = 0; I <= 10; I++) {
            Console.WriteLine("Method1 is : {0}", I);
  
            // When the value of I is equal to 5 then
            // this method sleeps for 6 seconds
            if (I == 5) {
                Thread.Sleep(6000);
            }
        }
    }
  
    // static method two
    public static void method2()
    {
        // It prints numbers from 0 to 10
        for (int J = 0; J <= 10; J++) {
            Console.WriteLine("Method2 is : {0}", J);
        }
    }
  
    // Main Method
    static public void Main()
    {
  
        // Creating and initializing threads
        Thread thr1 = new Thread(method1);
        Thread thr2 = new Thread(method2);
        thr1.Start();
        thr2.Start();
    }
}

Producción :

Method1 is : 0
Method1 is : 1
Method1 is : 2
Method1 is : 3
Method2 is : 0
Method2 is : 1
Method2 is : 2
Method2 is : 3
Method2 is : 4
Method2 is : 5
Method2 is : 6
Method2 is : 7
Method2 is : 8
Method2 is : 9
Method2 is : 10
Method1 is : 4
Method1 is : 5
Method1 is : 6
Method1 is : 7
Method1 is : 8
Method1 is : 9
Method1 is : 10

Explicación: Aquí, creamos e inicializamos dos hilos, es decir, thr1 y thr2 usando la clase Thread. Ahora usando thr1.Start();y thr2.Start();comenzamos la ejecución de ambos hilos. Ahora ambos subprocesos se ejecutan simultáneamente y el procesamiento de thr2 no depende del procesamiento de thr1 como en el modelo de un solo subproceso.

Nota: La salida puede variar debido al cambio de contexto.

Ventajas de los subprocesos múltiples:

• Ejecuta múltiples procesos simultáneamente.
• Maximice la utilización de los recursos de la CPU.
• Tiempo compartido entre múltiples procesos.