Jak tworzyć wątki w C#

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.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Wymagane pola są oznaczone *