Многопоточность в C # - Создание и методы многопоточности в C #

• Введение в многопоточность в C #

Введение в многопоточность в 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.

Пример использования класса 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();
)
)

Выход:

Примечание: не обязательно, чтобы методы, используемые в многопоточности, были статическими, как в двух приведенных выше примерах, оба метода, т.е. Method1 и Method2, являются статическими. Эти методы могут быть нестатическими, и в этом случае нам сначала нужно создать объект класса, содержащий методы, а затем получить доступ к методам с помощью объекта.

В C # программа всегда содержит один поток, то есть основной поток. Когда мы создаем другие потоки, это становится многопоточной программой, а в многопоточности 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 #

1. Помогает в поддержке адаптивного пользовательского интерфейса: иногда в нашем приложении используется трудоемкий метод. В этом случае, если мы сделаем наше приложение многопоточным, другой поток берет на себя ответственность за выполнение этого метода, в то время как основной поток может сосредоточиться на отзывчивости приложения. Таким образом, это не замораживает наше приложение, своевременно давая правильный ответ пользователю.
2. Повышает производительность приложения: если у нас столько потоков, сколько имеется ядер процессора, то каждый поток будет работать независимо, увеличивая количество вычислений в секунду.
3. Потоки минимизируют использование системных ресурсов, поскольку они совместно используют одно и то же адресное пространство.
4. Это делает код быстрее и проще одновременно.

Вывод - многопоточность в C #

Класс Thread предоставляет множество важных свойств, таких как Priority, Name, IsAlive, background, которые мы можем использовать в нашем многопоточном приложении. Синхронизация потоков - это метод, с помощью которого поток может получить доступ к ресурсу в течение определенного времени без прерывания других потоков, пока не выполнит свою задачу.

Рекомендуемые статьи

Это было руководство по многопоточности в C #. Здесь мы также обсудим их введение, синтаксис, создание и примеры многопоточности в C #. Вы также можете взглянуть на следующие статьи, чтобы узнать больше:

1. Объекты в C #
2. Деструктор в C #
3. Деструктор в C #
4. Наследование в C #
5. Деструктор в PHP | Примеры