Въведение в многопоточността в C #
За да разберем многопоточността в c #, нека първо разберем какво е нишка?
- Конецът е лек процес на тежест.
- Това е път за изпълнение на програма.
- Това е най-малката единица за обработка в операционна система.
- По този начин един процес може да има множество нишки.
И така, многопоточността е процес, който съдържа множество нишки, при които всяка нишка извършва различна дейност. Спестява време, защото множество задачи се изпълняват едновременно от различни нишки. Той увеличава използването на процесора и повишава ефективността на приложение. Това работи върху концепцията за споделяне на времето.
Синтаксис с обяснение
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();
За да създадем нишка, трябва да създадем обект от клас Thread. Конструкторът на клас Thread се позовава на ThreadStart. ThreadStart е делегат, който представлява метод, който трябва да бъде изпълнен, когато нишката започне изпълнението.
Нишката започва изпълнението, когато се извика методът Start ().
Можем да създадем нишка без да използваме делегат на ThreadStart, както е показано по-долу в синтаксиса:
Thread thread_name = new Thread(method_to_be_executed);
thread_name.Start();
Създаване на няколко конци в C #
За да създадем нишки, трябва да импортираме system.Threading пространство от имена. Можем да създаваме и инициализираме нишки, използвайки клас 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();
)
)
изход:
Пример с помощта на 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();
)
)
изход:
В C #, програмата винаги съдържа една нишка, т.е. Main Thread. Когато създаваме други нишки, тя се превръща в многопоточна програма и в C # многопоточност има два типа нишки:
- Преден план Тема : Тази нишка продължава да се изпълнява, докато завърши работата си, дори ако основната нишка се прекратява.
- Фонова нишка : Когато основната нишка приключи, фоновата нишка също спира да се изпълнява и завършва с основната нишка.
Методи с примери
Нека да видим някои често използвани методи от клас Thread с примери.
- Sleep (): Използва се за пауза на изпълнението на текущата нишка за определен период от време, така че другите нишки да започнат изпълнението.
Пример:
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();
)
)
изход:
Резултатът показва, че и двете нишки са изпълнени успоредно.
- Abort (): Използва се за прекратяване на нишката или можем да кажем, че се използва за постоянно спиране на изпълнението на нишката.
пример
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());
)
)
)
изход:
- Join (): Използва се, за да накара всички нишки за извикване да изчакат, докато текущата нишка завърши изпълнението и прекрати.
Пример:
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();
)
)
изход:
Предимства на многопоточността в C #
- Помага при поддържането на отзивчив потребителски интерфейс: Понякога имаме времеемък метод в нашето приложение. В този случай, ако направим нашето приложение многопоточно, тогава друга нишка поема отговорност за изпълнението на този метод, докато Main thread може да се съсредоточи върху отзивчивостта на приложението. По този начин няма да замрази нашето приложение, като своевременно дава правилен отговор на потребителя.
- Увеличава производителността на приложението: Ако имаме толкова нишки, колкото има процесорни ядра, всеки поток ще работи независимо, увеличавайки броя на изчисленията в секунда.
- Нишките минимизират използването на системни ресурси, тъй като те споделят едно и също адресно пространство.
- Това прави код едновременно по-бърз и опростен.
Заключение - Многопоточност в C #
Класът на нишката предоставя много важни свойства като Priority, Name, IsAlive, фон, които можем да използваме в нашето многопоточно приложение. Синхронизирането на нишката е техника, чрез която нишката може да получи достъп до ресурс за определено време без прекъсване на други нишки, докато не изпълни задачата си.
Препоръчителни статии
Това е ръководство за многопоточността в C #. Тук също обсъждаме тяхното въвеждане, синтаксис, създаване и примери за многопоточност в c #. Можете също така да разгледате следните статии, за да научите повече -
- Обекти в C #
- Разрушител в C #
- Разрушител в C #
- Наследяване в C #
- Destructor в PHP | Примери