Jak Tworzyć Wątki W C#

W języku C# system wielowątkowy jest oparty na klasie Thread, która hermetyzuje wykonywanie wątków. Ta klasa zawiera kilka metod i właściwości, które pomagają w zarządzaniu i tworzeniu wątków. Klasa ta jest zdefiniowana w przestrzeni nazw System.Threading. Przestrzeń nazw System.Threading udostępnia klasy i interfejsy, które są używane w programowaniu wielowątkowym.

Niektóre często używane klasy w tej przestrzeni nazw to:

• Mutex – jest używany do synchronizacji wątków
• Monitor – Ta klasa udostępnia mechanizm, który uzyskuje dostęp do obiektów w sposób zsynchronizowany.
• Semaphore – Ta klasa służy do ograniczania liczby wątków, które mogą jednocześnie uzyskiwać dostęp do zasobu lub puli zasobów.
• Thread – Ta klasa służy do tworzenia i kontrolowania wątku, ustawiania jego priorytetu i pobierania jego statusu.
• ThreadPool – Ta klasa udostępnia pulę wątków, których można używać do wykonywania zadań, publikowania elementów pracy, przetwarzania asynchronicznych operacji we/wy, oczekiwania w imieniu innych wątków i przetwarzania liczników czasu.
• ThreadLocal – Ta klasa zapewnia przechowywanie danych lokalnie dla wątków.
• Timer – Ta klasa udostępnia mechanizm wykonywania metody w wątku puli wątków w określonych odstępach czasu.
• Volatile – Ta klasa zawiera metody do wykonywania operacji na pamięci ulotnej.

Kroki, aby utworzyć wątek w programie C#:

1. Przede wszystkim import Przestrzeń nazw System.Threading, odgrywa ważną rolę w tworzeniu wątku w programie, ponieważ nie ma potrzeby każdorazowego wpisywania w pełni kwalifikowanej nazwy klasy.

Using System;
Using System.Threading;

2. Teraz utwórz i zainicjuj obiekt wątku w swojej metodzie głównej.

public static void main()
{
   Thread thread = new Thread(job1);
}

lub Możesz również użyć konstruktora ThreadStart do zainicjowania nowej instancji.

public static void main()
{
   Thread thr = new Thread(new ThreadStart(job1));
}

3. Teraz możesz wywołać swój obiekt wątku.

public static void main()
{
    Thread thr = new Thread(job1);
    thr.Start();
}

Przykład: programy ilustrują praktyczne realizacje powyższych kroków:

public class ExThread
{
   public void MyThread()  
   {
      for (int z = 0; z < 3; z++)
      {
         Console.WriteLine("Hello world");
      }
   }
}


public class Program
{
   public static void Main()
   {
      // Utworzenie obiektu klasy ExThread 
      ExThread obj = new ExThread();

      // Tworzenie wątku, korzystanie z klasy wątku Thread
      Thread thread = new Thread(new ThreadStart(obj.MyThread));
      thread.Start();
   }
}

Wynik działania

W powyższym przykładzie mamy klasę o nazwie ExThread, która zawiera niestatyczną metodę o nazwie MyThread(). Tworzymy więc instancję, klasy ExThread i wywołujemy ją w konstruktorze klasy ThreadStart, jak podano w tej instrukcji

Thread thread = new Thread(new ThreadStart(obj.MyThread));

Korzystanie z Thread thread = new Thread (new ThreadStart (obj.MyThread))
instrukcji utworzymy wątek o nazwie thread i zainicjujemy pracę tego wątku. Używając thread.Start()

Przykład 2 użycie metod statycznych

public class ExThread
{
   public static void Thread1()
   {
      for (int z = 0; z < 5; z++)
      {
         Console.WriteLine(z);
      }
   }

   public static void Thread2()
   {
      for (int z = 0; z < 5; z++)
      {
         Console.WriteLine(z);
      }
   }
}

public class Program
{
   public static void Main()
   {
      // Tworzenie i inicjowanie wątków
      Thread thread1 = new Thread(ExThread.Thread1);
      Thread thread2 = new Thread(ExThread.Thread2);
      thread1.Start();
      thread2.Start();
   }
}

Wynik działania

W powyższym przykładzie mamy klasę statyczną o nazwie ExThread zawierającą dwie statyczne metody o nazwach thread1() i thread2(). Nie musimy więc tworzyć instancji klasy ExThread.