Introduzione al multithreading in C #

Per capire il multithreading in c #, cerchiamo prima di capire cos'è un thread?

  • Un thread è un processo leggero.
  • È un percorso di esecuzione di un programma.
  • È la più piccola unità di elaborazione in un sistema operativo.
  • Pertanto, un processo può avere più thread.

Pertanto, il multithreading è un processo che contiene più thread in cui ogni thread esegue un'attività diversa. Risparmia tempo perché più attività vengono eseguite contemporaneamente da thread diversi. Aumenta l'utilizzo della CPU e aumenta l'efficienza di un'applicazione. Questo funziona sul concetto di condivisione del tempo.

Sintassi con spiegazione

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();

Per creare un thread, dobbiamo creare un oggetto della classe Thread. Il costruttore della classe Thread prende riferimento a ThreadStart. ThreadStart è un delegato che rappresenta un metodo che deve essere eseguito quando il thread inizia l'esecuzione.

Il thread inizia l'esecuzione quando viene chiamato il metodo Start ().

Possiamo creare un thread senza usare il delegato ThreadStart come mostrato nella sintassi seguente:

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

Creazione di più thread in C #

Per creare thread, è necessario importare il sistema. Spazio dei nomi di thread. Siamo in grado di creare e inizializzare thread utilizzando la classe Thread.

Esempio usando la classe thread

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();
)
)

Produzione:

Esempio di utilizzo del delegato 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();
)
)

Produzione:

Nota: non è necessario che i metodi utilizzati nel multithreading siano statici come nei due esempi precedenti, sia i metodi ie Method1 che Method2 sono statici. Questi metodi possono essere non statici e in tal caso, dobbiamo prima creare un oggetto della classe contenente metodi e quindi accedere ai metodi usando l'oggetto.

In C #, un programma contiene sempre un thread, ovvero il thread principale. Quando creiamo altri thread, diventa un programma multithreading e nel multithreading C #, ci sono due tipi di thread:

  • Discussione in primo piano : questa discussione continua fino a quando non termina il suo lavoro anche se termina la discussione principale.
  • Thread in background : quando il thread principale termina, anche il thread in background interrompe l'esecuzione e termina con il thread principale.

Metodi con esempi

Vediamo alcuni metodi comunemente usati della classe Thread con esempi.

  • Sleep (): utilizzato per mettere in pausa l'esecuzione del thread corrente per un periodo di tempo specificato, in modo che altri thread inizino l'esecuzione.

Esempio:

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();
)
)

Produzione:

L'output mostra che entrambi i thread sono stati eseguiti in parallelo.

  • Abort (): usato per terminare il thread o possiamo dire che è usato per fermare l'esecuzione del thread in modo permanente.

Esempio

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());
)
)
)

Produzione:

  • Join (): utilizzato per far attendere tutti i thread chiamanti fino a quando il thread corrente non completa l'esecuzione e termina.

Esempio:

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();
)
)

Produzione:

Vantaggi del multithreading in C #

  1. Aiuta a mantenere un'interfaccia utente reattiva: a volte abbiamo un metodo che richiede tempo nella nostra applicazione. In tal caso, se rendiamo la nostra applicazione multithread, allora altri thread si assumono la responsabilità dell'esecuzione di quel metodo mentre il thread principale può concentrarsi sulla reattività dell'applicazione. Pertanto, non bloccherà la nostra applicazione fornendo tempestivamente una risposta adeguata all'utente.
  2. Aumenta le prestazioni dell'applicazione: se abbiamo tanti thread quanti sono i core del processore, ciascun thread verrà eseguito in modo indipendente aumentando il numero di calcoli al secondo.
  3. I thread minimizzano l'uso delle risorse di sistema in quanto condividono lo stesso spazio degli indirizzi.
  4. Rende il codice più veloce e più semplice allo stesso tempo.

Conclusione - Multithreading in C #

La classe thread offre molte proprietà importanti come Priorità, Nome, IsAlive, background che possiamo usare nella nostra applicazione multithreading. La sincronizzazione dei thread è una tecnica con cui un thread può accedere a una risorsa per un determinato momento senza l'interruzione di altri thread fino a quando non completa il proprio compito.

Articoli consigliati

Questa è stata una guida al multithreading in C #. Qui discutiamo anche la loro introduzione, sintassi, creazione ed esempi di multithreading in c #. Puoi anche dare un'occhiata ai seguenti articoli per saperne di più–

  1. Oggetti in C #
  2. Distruttore in C #
  3. Distruttore in C #
  4. Eredità in C #
  5. Distruttore in PHP | Esempi

Categoria:

Sviluppo software