Многопоточность в C#: преимущества, основы и рекомендации

Что такое многопоточное программирование

Многопоточность является фундаментальной концепцией разработки программного обеспечения. В C# многопоточное программирование необходимо разработчикам программного обеспечения, работающим с .NET Framework. Разработчики широко используют многопоточность в C# , поскольку она позволяет им эффективно создавать сложные и быстро реагирующие приложения.

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

Преимущества и преимущества многопоточного программирования

При одновременном выполнении многопоточность повышает эффективность приложений. Наиболее распространенные преимущества потока C# включают следующее:

• Улучшенная производительность приложений: благодаря многопоточности приложения работают быстрее, когда несколько задач выполняются в одном и том же пространстве.В совокупности это сокращает время выполнения и уступает место нескольким задачам.
• Увеличение пропускной способности. Многозадачность в C# повышает пропускную способность приложений.Когда два разных потока выполняются одновременно, это может сэкономить время и ресурсы.
• Улучшенная скорость отклика: с помощью многопоточности пользователь может получить доступ к внешнему интерфейсу приложения, в то время как программа работает в фоновом режиме.
• Повышенное использование ресурсов. Многопоточность позволяет пользователям более эффективно обращаться к системным ресурсам.Например, потоки могут совместно использовать такие ресурсы, как файлы, память и устройства ввода-вывода, прокладывая путь к эффективности.
• Более доступное программирование: многопоточность упрощает программирование, поскольку пользователи могут создавать потоки независимо друг от друга.Это также позволяет пользователям отлаживать и тестировать приложения изолированно.
• Оптимизированная связь: синхронизация потоков обеспечивает лучшую связь между процессами.Его можно использовать для более доступной связи между потоками.

Во-первых, это влияет на отдельные объекты, которые можно синхронизировать. Во-вторых, его можно использовать с классами System.Threading и Interlocked.

Основные понятия многопоточности в C#

Многопоточность позволяет пользователям выполнять несколько задач одновременно с помощью нескольких ядер процессора. Вот основные понятия, используемые в многопоточности:

• Потоки. Потоки — это основные единицы многопоточности, которые помогают выполнять процесс.Это пути выполнения в данной программе, которые могут выполняться одновременно с другими потоками.

В C# мы можем найти два типа потоков, а именно потоки переднего плана и фоновые потоки. Средний класс потока включает в себя имя, приоритет, isAlive, ThreadState, Start(), Suspend(), Resume() и Join().

• Пул потоков: пул потоков — это поток, который помогает выполнять задачи.Это позволяет операционной системе повторно использовать существующие потоки и сводит к минимуму риск возможных накладных расходов.
• Синхронизация. Синхронизация игнорирует доступ к другим потокам для выполнения нескольких операций.Это важный процесс для поддержания целостности данных и предотвращения накладных расходов.
• Взаимная блокировка. Взаимная блокировка — это ошибка, возникающая, когда два потока совместно используют ресурсы и пытаются продолжить работу, но безуспешно.Это может привести к зависанию системы или даже к ожиданию.
• Асинхронное программирование: асинхронное программирование позволяет запускать несколько задач в фоновом режиме, позволяя основному потоку работать без перерыва.Он прокладывает путь к множеству адаптивных пользовательских интерфейсов, повышая производительность приложений.

Создание и запуск потоков

Создание и запуск могут быть проще с этими примерами. Пример многопоточности C# приведен ниже:

с помощью системы;

использование System.Threading;

программа класса {

статическая пустота Main () {

инт рабочий индекс = 0;

Thread workerThread = new Thread (new ThreadStart (Worker));

рабочий поток.Начать();

for (int mainIndex = 1; mainIndex <= 10; mainIndex++) {

Console.WriteLine("Основной поток: {0}", mainIndex);

Нить.Сон(200);

}

рабочий поток.Присоединиться();

}

статическая пустота Worker () {

for (int workerIndex = 1; workerIndex <= 10; workerIndex++) {

Console.WriteLine("Рабочий поток: {0}", workerIndex * 2);

Нить.Сон(200);

}

}

}

Выход:

Основная нить: 1

Рабочий поток: 2

Основная нить: 2

Рабочая нить: 4

Основная нить: 3

Рабочая нить: 6

Основная нить: 4

Рабочая нить: 8

Основная нить: 5

Рабочая нить: 10

Основная нить: 6

Рабочая нить: 12

Основная нить: 7

Рабочая нить: 14

Основная нить: 8

Рабочая нить: 16

Основная нить: 9

Рабочая нить: 18

Основная нить: 10

Рабочая нить: 20

Объяснение: В этом выводе оба потока работают одновременно для печати чисел от 1 до 10 и от 2 до 20, последнее удваивается из индекса цикла.В этом примере использовался метод сна потока C# (Thread.Sleep).

Таким же образом мы рассмотрим еще один пример потока C# , использующий поток переднего плана:

с помощью системы;

использование System.Threading;

программа класса {

статическая пустота Main () {

Thread myThread = новый поток (рабочий);

мояПоток.Начать();

Console.WriteLine("Основной поток: запущен");

для (целое я = 1; я <= 5; я ++) {

Console.WriteLine("Основной поток: количество {0}", i);

Thread.Sleep(500);

}

Console.WriteLine("Основной поток: Завершен");

}

статическая пустота Worker () {

для (в j = 1; j <= 5; j++) {

Console.WriteLine("Рабочий поток: количество {0}", j * 3);

Thread.Sleep(750);

}

Console.WriteLine("Рабочий поток: завершен");

}

}

Выход:

Основная тема: запущена

Рабочий поток: количество 3

Основная тема: Граф 1

Рабочая нить: счет 6

Основная тема: Граф 2

Рабочий поток: счет 9

Основная тема: счет 3

Рабочая нить: счет 12

Основная тема: счет 4

Рабочая нить: счет 15

Основная тема: счет 5

Рабочий поток: Завершен

Основная тема: завершена

Объяснение: Эти выходные данные показывают, как два потока работают одновременно.Поскольку основной и фоновый потоки работают параллельно, основной поток печатает числа от 1 до 5. Рабочий поток печатает числа, кратные от 3 до 15.

Ознакомьтесь с курсами по разработке программного обеспечения на upGrad, чтобы повысить квалификацию.

Прочтите наши популярные статьи, связанные с разработкой программного обеспечения

Синхронизация потоков

Синхронизация потоков включает в себя коллективную координацию нескольких потоков в программе. Это гарантирует, что программа выполняется в определенном порядке, дающем доступ к общим ресурсам.

В C# это делается с помощью примитивов синхронизации, таких как ключевое слово lock, объекты синхронизации и класс Interlocked.

Пример синхронизации потока C# приведен ниже:

Использование системы;

Использование System.Threading;

класс TablePrinter

{

публичная пустота PrintTable()

{

замок (этот)

{

для (целое я = 3; я <= 8; я ++)

{

Нить.Сон(200);

Console.WriteLine(i*5);

}

}

}

}

программа класса

{

public static void Main(string[] args)

{

TablePrinter tp = новый TablePrinter();

Поток t1 = новый поток (новый ThreadStart (tp.PrintTable));

Поток t2 = новый поток (новый ThreadStart (tp.PrintTable));

t1.Старт();

t2.Старт();

}

}

Выход:

15

20

25

30

35

40

45

50

55

60

Изучите наши бесплатные курсы по разработке программного обеспечения

Тупики

Взаимоблокировки в многопоточности случаются, когда по крайней мере два или более двух потоков зависят от набора ресурсов. Когда один поток перекрывает путь к справке, а другой пытается сделать то же самое, он становится тупиком.

Например, если поток A заблокировал ресурс 1 и ожидает доступа к ресурсу 2, а поток B ожидает доступа к ресурсу 1, это может привести к взаимоблокировке.

Пример приведен ниже:

с помощью системы;

использование System.Threading;

пространство имен

{

Пример публичного класса

{

статический объект только для чтения firstLock = new object();

статический объект только для чтения secondLock = new object();

статическая пустота ThreadJob()

{

Console.WriteLine("\t\t\t\tБлокировка firstLock");

замок (первый замок)

{

Console.WriteLine("\t\t\t\tLocked firstLock");

Thread.Sleep(1500);

Console.WriteLine("\t\t\t\tБлокировка secondLock");

замок (второй замок)

{

Console.WriteLine("\t\t\t\tLocked secondLock");

}

Console.WriteLine("\t\t\t\tReleased secondLock");

}

Console.WriteLine("\t\t\t\tReleased firstLock");

}

статическая пустота Main()

{

новый поток (новый ThreadStart (ThreadJob)). Start ();

Нить.Сон(1000);

Console.WriteLine("Блокировка secondLock");

замок (второй замок)

{

Console.WriteLine("Вторая блокировка заблокирована");

Console.WriteLine("Блокировка firstLock");

замок (первый замок)

{

Console.WriteLine("FirstLock заблокирован");

}

Console.WriteLine("Снята первая блокировка");

}

Console.WriteLine("Вторая блокировка снята");

Консоль.Прочитать();

}

}

}

Выход:

Блокировка второго замка

Заблокирован второй замок

Блокировка firstLock

Сначала заблокированоЗамок

Выпущено первымЗамок

Снят второй замок

Востребованные навыки разработки программного обеспечения

Пулы потоков

Пулы потоков помогают управлять несколькими потоками выполнения в многопоточной среде на C#. Это гарантирует, что все потоки имеют доступ к контролируемым ресурсам, не вызывая взаимоблокировок.

Менеджер пула потоков следит за пулом потоков, где он отвечает за создание, уничтожение и планирование потоков.

Вот пример пула потоков, использующего TPL (библиотека параллельных задач):

с помощью системы;

использование System.Threading.Tasks;

программа класса

{

статическая пустота Main()

{

Задача<строка> задача = Task.Factory.StartNew<строка>

(() => DownloadString("http://www.example.com/"));

строковый результат = задача.Результат;

Console.WriteLine(результат);

Консоль.Прочитать();

}

статическая строка DownloadString (строка uri)

{

используя (var wc = новый System.Net.WebClient())

вернуть wc.DownloadString(uri);

}

Выход:

Результат зависит от содержимого, доступного на веб-странице. Эта программа обеспечит загрузку содержимого веб-страницы с указанного URL-адреса. Затем он их распечатает.

Асинхронное программирование с библиотекой параллельных задач (TPL)

Библиотека параллельных задач (TPL) — это мощный инструмент для работы с APIS и общедоступными типами. Он обрабатывает System.Threading и System.Threading.Tasks .

.NET Framework 4 предлагает API уровня языка и платформы для разработчиков, стремящихся писать параллельный код. С помощью TPL асинхронное программирование позволяет запускать программы, не блокируя основной поток.

Вот пример асинхронного программирования с TPL:

Task<string> task = Task.Factory.StartNew<string>(() => {

вернуть «результат»;

});

строковый результат = задача.Результат;

асинхронная задача MyMethod() {

строковый результат = ожидание задачи;

}

Ознакомьтесь с нашимибесплатными технологическими курсами , чтобы получить преимущество над конкурентами.

Лучшие практики многопоточности в C#

Многопоточность может сэкономить время с точки зрения производительности и многозадачности. Чтобы узнать больше о том, как работает многопоточность, вы можете выбрать степень магистра компьютерных наук в LJMU .

Вот несколько рекомендаций, которые помогут пользователям сэкономить время и добиться максимальной эффективности.

• Используйте потокобезопасные коллекции. Параллельные коллекции .NET Framework предоставляют потокобезопасную версию каждой коллекции, что упрощает эффективную работу многопоточности.Эти коллекции включают списки, запросы и словари.
• Реализуйте синхронизацию потоков: пользователи могут быстро реализовать блокировки, мониторы и семафоры благодаря характеру инструментов потоков.
• Используйте пулы потоков: многопоточность может быть проще и эффективнее для систем благодаря тому, что подавляющее большинство пулов потоков выполняется пользователями.В то же время пользователи могут использовать его для автоматического создания потоков.
• Используйте локальное хранилище потока. Практикуя многопоточность, обеспечьте доступ к определенному ресурсу, оптимизировав локальное хранилище потока и предоставив доступ к нескольким потокам.
• Избегайте совместного использования изменяемых состояний: общие изменяемые состояния приведут только к ошибкам и условиям гонки, что может быть непросто.Убедитесь, что любой ценой избегаете изменяемых состояний.
• Используйте асинхронную модель. Асинхронные методы помогают выполнять несколько задач параллельно, не запуская их заново и не оставляя в очереди.
• Избегайте взаимоблокировок: при выполнении программ, использующих многопоточность, можно ожидать взаимоблокировок.При написании программы старайтесь запускать поток только после другого, избегая взаимоблокировок.
• Используйте токены отмены: токены отмены позволяют без проблем завершать потоки и избегать взаимоблокировок.

Изучите наши популярные курсы по программной инженерии

Заключение

Многопоточность в C# остается важной концепцией благодаря своей высокоэффективной модели. Он предоставляет программистам гибкий способ разделить рабочую нагрузку программы на несколько задач, выполняемых одновременно и независимо.

Хотя многопоточность может быть очень полезной, она может привести к потенциальным препятствиям, если не будет реализована тщательно.

С глобальным бюджетом на корпоративное программное обеспечение, превышающим 856 миллиардов долларов в период с 2009 по 2023 год, разработка программного обеспечения обещает разработчикам блестящую карьеру.

Подайте заявку на участие в буткемпе Full Stack Software Development от upGrad прямо сейчас! Полный курс разработки стека может стать трамплином для разработчиков, которые хотят раскрыть свой потенциал в компьютерных науках.