C# Language
Enhebrado

Observaciones

Demostración de subprocesos completa simple

class Program
{
    static void Main(string[] args)
    {
        // Create 2 thread objects.  We're using delegates because we need to pass 
        // parameters to the threads.  
        var thread1 = new Thread(new ThreadStart(() => PerformAction(1)));
        var thread2 = new Thread(new ThreadStart(() => PerformAction(2)));

        // Start the threads running 
        thread1.Start();
        // NB: as soon as the above line kicks off the thread, the next line starts; 
        // even if thread1 is still processing.
        thread2.Start();

        // Wait for thread1 to complete before continuing
        thread1.Join();
        // Wait for thread2 to complete before continuing
        thread2.Join();

        Console.WriteLine("Done");
        Console.ReadKey();
    }

    // Simple method to help demonstrate the threads running in parallel.
    static void PerformAction(int id)
    {
        var rnd = new Random(id);
        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine("Thread: {0}: {1}", id, i);
            Thread.Sleep(rnd.Next(0, 1000));
        }
    }
}

Demostración de subprocesos completa simple usando tareas

class Program
{
    static void Main(string[] args)
    {
        // Run 2 Tasks.  
        var task1 = Task.Run(() => PerformAction(1)));
        var task2 = Task.Run(() => PerformAction(2)));

        // Wait (i.e. block this thread) until both Tasks are complete.
        Task.WaitAll(new [] { task1, task2 });
        
        Console.WriteLine("Done");
        Console.ReadKey();
    }

    // Simple method to help demonstrate the threads running in parallel.
    static void PerformAction(int id)
    {
        var rnd = new Random(id);
        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine("Task: {0}: {1}", id, i);
            Thread.Sleep(rnd.Next(0, 1000));
        }
    }
}

Paralismo explícito de tareas

    private static void explicitTaskParallism()
    {
        Thread.CurrentThread.Name = "Main";

        // Create a task and supply a user delegate by using a lambda expression. 
        Task taskA = new Task(() => Console.WriteLine($"Hello from task {nameof(taskA)}."));
        Task taskB = new Task(() => Console.WriteLine($"Hello from task {nameof(taskB)}."));

        // Start the task.
        taskA.Start();
        taskB.Start();

        // Output a message from the calling thread.
        Console.WriteLine("Hello from thread '{0}'.",
                          Thread.CurrentThread.Name);
        taskA.Wait();
        taskB.Wait();
        Console.Read();
    }

Paralelismo implícito de tareas

    private static void Main(string[] args)
    {
        var a = new A();
        var b = new B();
        //implicit task parallelism
        Parallel.Invoke(
            () => a.DoSomeWork(),
            () => b.DoSomeOtherWork()
            );

      }

Creando e iniciando un segundo hilo

Si está realizando varios cálculos largos, puede ejecutarlos al mismo tiempo en diferentes subprocesos en su computadora. Para hacer esto, hacemos un nuevo hilo y lo apuntamos a un método diferente.

using System.Threading;

class MainClass {
    static void Main() {
        var thread = new Thread(Secondary);
        thread.Start();
    }

    static void Secondary() {
        System.Console.WriteLine("Hello World!");
    }
}

Comenzando un hilo con parámetros

utilizando System.Threading;

class MainClass {
    static void Main() {
        var thread = new Thread(Secondary);
        thread.Start("SecondThread");
    }

    static void Secondary(object threadName) {
        System.Console.WriteLine("Hello World from thread: " + threadName);
    }
}

Creando un hilo por procesador

Environment.ProcessorCount Obtiene el número de procesadores lógicos en la máquina actual.

El CLR luego programará cada subproceso a un procesador lógico, esto teóricamente podría significar cada subproceso en un procesador lógico diferente, todos los subprocesos en un solo procesador lógico o alguna otra combinación.

using System;
using System.Threading;

class MainClass {
    static void Main() {
        for (int i = 0; i < Environment.ProcessorCount; i++) {
            var thread = new Thread(Secondary);
            thread.Start(i);
        }
        
    }

    static void Secondary(object threadNumber) {
        System.Console.WriteLine("Hello World from thread: " + threadNumber);
    }
}

Evitar leer y escribir datos simultáneamente

A veces, quieres que tus hilos compartan datos simultáneamente. Cuando esto sucede, es importante conocer el código y bloquear cualquier parte que pueda salir mal. Un ejemplo simple de dos hilos contando se muestra a continuación.

Aquí hay un código peligroso (incorrecto):

using System.Threading;

class MainClass 
{    
    static int count { get; set; }

    static void Main() 
    {
        for (int i = 1; i <= 2; i++)
        {
            var thread = new Thread(ThreadMethod);
            thread.Start(i);
            Thread.Sleep(500);
        }
    }

    static void ThreadMethod(object threadNumber) 
    {
        while (true)
        {
            var temp = count;
            System.Console.WriteLine("Thread " + threadNumber + ": Reading the value of count.");
            Thread.Sleep(1000);
            count = temp + 1;
            System.Console.WriteLine("Thread " + threadNumber + ": Incrementing the value of count to:" + count);
            Thread.Sleep(1000);
        }
    }
}

Notarás, en lugar de contar 1,2,3,4,5 ... contamos 1,1,2,2,3 ...

Para solucionar este problema, debemos bloquear el valor de conteo, de modo que varios subprocesos diferentes no puedan leer y escribir en él al mismo tiempo. Con la adición de un candado y una llave, podemos evitar que los hilos accedan a los datos simultáneamente.

using System.Threading;

class MainClass
{

    static int count { get; set; } 
    static readonly object key = new object();

    static void Main()
    {
        for (int i = 1; i <= 2; i++)
        {
            var thread = new Thread(ThreadMethod);
            thread.Start(i);
            Thread.Sleep(500);
        }
    }

    static void ThreadMethod(object threadNumber)
    {
        while (true)
        {
            lock (key) 
            {
                var temp = count;
                System.Console.WriteLine("Thread " + threadNumber + ": Reading the value of count.");
                Thread.Sleep(1000);
                count = temp + 1;
                System.Console.WriteLine("Thread " + threadNumber + ": Incrementing the value of count to:" + count);
            }
            Thread.Sleep(1000);
        }
    }
}

Parallel.ForEach Loop

Si tiene un bucle foreach que desea acelerar y no le importa en qué orden está la salida, puede convertirlo en un bucle foreach paralelo haciendo lo siguiente:

using System;
using System.Threading;
using System.Threading.Tasks;

public class MainClass {

    public static void Main() {
        int[] Numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        // Single-threaded
        Console.WriteLine("Normal foreach loop: ");
        foreach (var number in Numbers) {
            Console.WriteLine(longCalculation(number));
        }
        // This is the Parallel (Multi-threaded solution)
        Console.WriteLine("Parallel foreach loop: ");
        Parallel.ForEach(Numbers, number => {
            Console.WriteLine(longCalculation(number));
        });
    }

    private static int longCalculation(int number) {
        Thread.Sleep(1000); // Sleep to simulate a long calculation
        return number * number;
    }
}

Puntos muertos (dos hilos esperando el uno al otro)

Un interbloqueo es lo que ocurre cuando dos o más subprocesos están esperando que se completen o liberen un recurso de tal manera que esperen para siempre.

Un escenario típico de dos subprocesos que esperan que se completen entre sí es cuando un subproceso de la GUI de Windows Forms espera un subproceso de trabajo y el subproceso de trabajo intenta invocar un objeto administrado por el subproceso de la GUI. Observe que con este ejemplo de código, hacer clic en el botón 1 hará que el programa se bloquee.

private void button1_Click(object sender, EventArgs e)
{
    Thread workerthread= new Thread(dowork);
    workerthread.Start();
    workerthread.Join();
    // Do something after
}

private void dowork()
{
    // Do something before
    textBox1.Invoke(new Action(() => textBox1.Text = "Some Text"));
    // Do something after
}

workerthread.Join() es una llamada que bloquea el subproceso de llamada hasta que workerthread se complete. textBox1.Invoke(invoke_delegate) es una llamada que bloquea el subproceso de llamada hasta que el subproceso de la GUI haya procesado invoke_delegate, pero esta llamada provoca interbloqueos si el subproceso de la GUI ya está esperando a que se complete el subproceso de la llamada.

Para solucionar esto, uno puede usar una forma no bloqueante de invocar el cuadro de texto en su lugar:

private void dowork()
{
    // Do work
    textBox1.BeginInvoke(new Action(() => textBox1.Text = "Some Text"));
    // Do work that is not dependent on textBox1 being updated first
}

Sin embargo, esto causará problemas si necesita ejecutar un código que depende de que el cuadro de texto se actualice primero. En ese caso, ejecute eso como parte de la invocación, pero tenga en cuenta que esto hará que se ejecute en el hilo de la GUI.

private void dowork()
{
    // Do work
    textBox1.BeginInvoke(new Action(() => {
        textBox1.Text = "Some Text";
        // Do work dependent on textBox1 being updated first, 
        // start another worker thread or raise an event
    }));
    // Do work that is not dependent on textBox1 being updated first
}

Alternativamente, inicie un hilo completamente nuevo y deje que ese haga la espera en el hilo de la GUI, para que ese hilo de trabajo pueda completarse.

private void dowork()
{
    // Do work
    Thread workerthread2 = new Thread(() =>
    {
        textBox1.Invoke(new Action(() => textBox1.Text = "Some Text"));
        // Do work dependent on textBox1 being updated first, 
        // start another worker thread or raise an event
    });
    workerthread2.Start();
    // Do work that is not dependent on textBox1 being updated first
}

Para minimizar el riesgo de encontrarse con un interbloqueo de espera mutua, siempre evite referencias circulares entre hilos cuando sea posible. Una jerarquía de subprocesos en la que los subprocesos de menor rango solo dejan mensajes para los subprocesos de mayor rango y nunca los espera, no se encontrará con este tipo de problema. Sin embargo, aún sería vulnerable a puntos muertos en función del bloqueo de recursos.

Puntos muertos (mantener el recurso y esperar)

Un interbloqueo es lo que ocurre cuando dos o más subprocesos están esperando que se completen o liberen un recurso de tal manera que esperen para siempre.

Si thread1 mantiene un bloqueo en el recurso A y está esperando que se libere el recurso B, mientras que thread2 mantiene el recurso B y está esperando que se libere el recurso A, están bloqueados.

Al hacer clic en el botón 1 para el siguiente código de ejemplo, su aplicación entrará en el estado de interbloqueo mencionado anteriormente y se bloqueará

private void button_Click(object sender, EventArgs e)
{
    DeadlockWorkers workers = new DeadlockWorkers();
    workers.StartThreads();
    textBox.Text = workers.GetResult();
}

private class DeadlockWorkers
{
    Thread thread1, thread2;

    object resourceA = new object();
    object resourceB = new object();

    string output;

    public void StartThreads()
    {
        thread1 = new Thread(Thread1DoWork);
        thread2 = new Thread(Thread2DoWork);
        thread1.Start();
        thread2.Start();
    }

    public string GetResult()
    {
        thread1.Join();
        thread2.Join();
        return output;
    }

    public void Thread1DoWork()
    {
        Thread.Sleep(100);
        lock (resourceA)
        {
            Thread.Sleep(100);
            lock (resourceB)
            {
                output += "T1#";
            }
        }
    }

    public void Thread2DoWork()
    {
        Thread.Sleep(100);
        lock (resourceB)
        {
            Thread.Sleep(100);
            lock (resourceA)
            {
                output += "T2#";
            }
        }
    }
}

Para evitar estar bloqueado de esta manera, se puede usar Monitor.TryEnter (lock_object, timeout_in_milliseconds) para verificar si ya hay un bloqueo en un objeto. Si Monitor.TryEnter no logra adquirir un bloqueo en lock_object antes de timeout_in_milliseconds, devuelve falso, lo que le da al hilo la oportunidad de liberar otros recursos retenidos y el rendimiento, dando así a otros hilos la oportunidad de completar, como en esta versión ligeramente modificada del anterior :

private void button_Click(object sender, EventArgs e)
{
    MonitorWorkers workers = new MonitorWorkers();
    workers.StartThreads();
    textBox.Text = workers.GetResult();
}

private class MonitorWorkers
{
    Thread thread1, thread2;

    object resourceA = new object();
    object resourceB = new object();

    string output;

    public void StartThreads()
    {
        thread1 = new Thread(Thread1DoWork);
        thread2 = new Thread(Thread2DoWork);
        thread1.Start();
        thread2.Start();
    }

    public string GetResult()
    {
        thread1.Join();
        thread2.Join();
        return output;
    }

    public void Thread1DoWork()
    {
        bool mustDoWork = true;
        Thread.Sleep(100);
        while (mustDoWork)
        {
            lock (resourceA)
            {
                Thread.Sleep(100);
                if (Monitor.TryEnter(resourceB, 0))
                {
                    output += "T1#";
                    mustDoWork = false;
                    Monitor.Exit(resourceB);
                }
            }
            if (mustDoWork) Thread.Yield();
        }
    }

    public void Thread2DoWork()
    {
        Thread.Sleep(100);
        lock (resourceB)
        {
            Thread.Sleep(100);
            lock (resourceA)
            {
                output += "T2#";
            }
        }
    }
}

Tenga en cuenta que esta solución temporal se basa en que el subproceso2 es obstinado en cuanto a sus bloqueos y el subproceso1 está dispuesto a ceder, de modo que el subproceso2 siempre tiene prioridad. También tenga en cuenta que el subproceso1 debe rehacer el trabajo que realizó después de bloquear el recurso A, cuando cede. Por lo tanto, tenga cuidado al implementar este enfoque con más de un subproceso de rendimiento, ya que correrá el riesgo de ingresar a un llamado Livelock, un estado que se produciría si dos subprocesos siguieran haciendo el primer bit de su trabajo y luego se rindieran mutuamente. , volviendo a empezar repetidamente.