Wątek jest definiowany jako ścieżka wykonywania programu. Każdy z wątków definiuje unikalny przepływ sterowania. Jeśli aplikacja wymaga skomplikowanych i czasochłonnych czynności, wówczas można ustawić różne ścieżki wykonywania części programu tak, aby każdy wątek wykonywał określoną pracę.

Wątki są lekkimi procesami. Jednym z przykładów użycia jest operacja projektowania współczesnych systemów operacyjnych. Korzystanie z wątków pozwala zaoszczędzić straty mocy obliczeniowej procesora oraz pozwala na wzrost wydajności działania aplikacji.

We wszystkich powyżyszch przykładach pisaliśmy programy, które działały jako pojedynczy proces, który uruchamiał instancję naszej aplikacji. Jednakże, pisząc programy w taki sposób jesteśmy w stanie wykonywać tylko jedno zadanie w danym momencie. Aby wykonywać więcej niż jedno zadanie w danym czasie należy program podzielić na mniejsze wątki.

Cykl życia wątku zaczyna się kiedy obiekt klasy System.Threading.Thread zostaje utworzony oraz kończy się, gdy wątek jest przerywany lub zakończy wykonywanie.

Poniżej przedstawiono różne stany w cyklu życia wątku:

• Stan przed rozpoczęciem: sytuacja w której doszło do utworzenia instancji wątku ale metoda Start() nie została wywołana;
• Stan gotowości: sytuacja w której wątek jest gotowy do działania i oczekuje na cykl procesora;
• Stan wstrzymania: wątek nie zostanie wykonany, gdy:
  • tryb uśpienia został wywołany;
  • metoda Wait() została wywołana;
  • jest zablokowany przez operacje I/O;
• Stan martwy: sytuacja w której wątek zakończył wykonywanie lub został przerwany.

W języku C# klasa System.Threading.Thread pozwala na pracę z wątkami. Pozwala na tworzenie oraz dostęp do poszczególnych wątków w wielowątkowej aplikacji. Pierwszy wątek do wykonania w procesie nazywany jest głównym wątkiem (Main).

Gdy program zaczyna wykonywanie, główny wątek jest tworzony automatycznie. Wątki tworzone przy użyciu klasy Thread nazywane są wątkami pochodnymi głównego wątku. Dostęp do wątku można uzyskać dzięki właściwości CurrentThread klasy Thread.

Poniższy program pokazuje wykonanie głównego wątku:

using System;
using System.Threading;
namespace MultiThreading
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread th = Thread.CurrentThread;
            th.Name = "GłównyWątek";
            Console.WriteLine("To jest: {0}", th.Name);
            Console.ReadKey();
            // Wynik działania programu
            // To jest: GlównyWatek
        }
    }
}

Poniżej tabela zawierająca najczęściej używane właściwości klasy Thread:

Poniżej lista najczęściej używanych metod klasy Thread:

Wątki są tworzone poprzez rozszerzenie klasy Thread. Rozszerzona klasa Thread wywołuje metodę Start(), aby rozpocząć wykonywanie wątku pochodnego. Poniżej przykład pokazujący koncepcję używania wątków:

using System;
using System.Threading;
namespace MultiThreadingCreate
{
    class Program
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Wątek pochodny wystartował");
        }
        static void Main(string[] args)
        {
            ThreadStart ts = new ThreadStart(CallToChildThread);
            Console.WriteLine("Główny wątek: Tworzenie wątku pochodnego");
            Thread pochodnyWatek = new Thread(ts);
            // Uruchamiamy wątek pochodny
            pochodnyWatek.Start();
            Console.ReadKey();
            // Wynik działania programu
            // Glówny watek: Tworzenie watku pochodnego
            // Watek pochodny wystartowal
        }
    }
}

Klasa Thread dostarcza nam metody pozwalające na zarządzanie wątkami.

Poniższy przykład pokazuje przykład użycia metody Sleep(), która pozwala powstrzymać wykonywanie wątka na pewien określony okres czasu:

using System;
using System.Threading;
namespace MultiThreadingSleep
{
    class Program
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Wątek pochodny wystartował");
            // Zatrzymamy wykonanie wątku na 5 sekund - 5000 milisekund
            int sleepFor = 5000;
            Console.WriteLine("Wątek zostanie zatrzymany na: {0} sekund", sleepFor / 1000);
            Thread.Sleep(sleepFor);
            Console.WriteLine("Wznowienie wykonywania wątku");
        }
        static void Main(string[] args)
        {
            ThreadStart ts = new ThreadStart(CallToChildThread);
            Console.WriteLine("Główny wątek: Tworzenie wątku pochodnego");
            Thread pochodnyWatek = new Thread(ts);
            // Uruchamiamy wątek pochodny
            pochodnyWatek.Start();
            Console.ReadKey();
            // Wynik działanie programu
            // Glówny watek: Tworzenie watku pochodnego
            // Watek pochodny wystartowal
            // Watek zostanie zatrzymany na: 5 sekund
            // Wznowienie wykonywania watku
        }
    }
}

Metoda Abort() jest używana do niszczenia wątków.

Środowisko wykonawcze przerywa wątek rzucając wyjątek ThreadAbortException. Wyjątek ten jest specjalnym wyjątkiem, który może być wyłapany przez kod aplikacji, ale jest ponownie rzucony pod koniec wykonywania bloku catch chyba, że zostanie wywołana metoda ResetAbort().

Poniższy przykład pokazuje powyższą koncepcję:

using System;
using System.Threading;
namespace MultiThreadingDestroy
{
    class Program
    {
        public static void CallToChildThread()
        {
            try
            {
                Console.WriteLine("Wątek pochodny wystartował");
                // wykonanie jakichś instrukcji, np. odliczanie do 10
                for (int i = 0; i < 10; i++)
                {
                    // przerwanie wykonywania wątku na okreslony okres czasu
                    Thread.Sleep(250);
                    Console.WriteLine(i);
                }
                Console.WriteLine("Wątek został wykonany");
            }
            catch (ThreadAbortException e)
            {
                Console.WriteLine("Wyjątek: ThreadAbortException");
            }
            finally
            {
                Console.WriteLine("Nie można złapać wyjątku");
            }
            
        }
        static void Main(string[] args)
        {
            ThreadStart ts = new ThreadStart(CallToChildThread);
            Console.WriteLine("Główny wątek: Tworzenie wątku pochodnego");
            Thread pochodnyWatek = new Thread(ts);
            // Uruchamiamy wątek pochodny
            pochodnyWatek.Start();
            // zatrzymanie głównego wątku
            Thread.Sleep(2000);
            // przerwanie wątku pochodnego
            Console.WriteLine("Główny wątek: przerwanie wątku pochodnego");
            pochodnyWatek.Abort();
            Console.ReadKey();
            // Wynik działania programu
            // Glówny watek: Tworzenie watku pochodnego
            // Watek pochodny wystartowal
            // 0
            // 1
            // 2
            // 3
            // 4
            // 5
            // 6
            // Glówny watek: przerwanie watku pochodnego
            // Wyjatek: ThreadAbortException
            // Nie mozna zlapac wyjatku
        }
    }
}