Книжная полка Сохранить
Размер шрифта:
А
А
А
|  Шрифт:
Arial
Times
|  Интервал:
Стандартный
Средний
Большой
|  Цвет сайта:
Ц
Ц
Ц
Ц
Ц

Параллельное программирование на C# и .NET Core

Покупка
Артикул: 833973.01.99
Доступ онлайн
1 049 ₽
В корзину
Книга представляет подход к параллельному программированию с учетом современных реалий. Информация структурирована таким образом, чтобы она легко усваивалась, даже если читатель не обладает специальными знаниями. Рассматриваются общие принципы написания параллельного и асинхронного кода; реализация параллелизма данных показана на коротких и простых примерах. В конце глав приводятся вопросы для повторения пройденного. Издание предназначено для программистов C#, которые хотят изучить концепции параллельного программирования и многопоточности, а затем использовать полученные знания для приложений, построенных на базе .NET Core. Также оно пригодится специалистам, желающим ознакомиться с принципами работы параллельного программирования на современном оборудовании.
22
45
46
74
93
109
111
142
155
170
172
184
202
227
254
Танвар, Ш. Параллельное программирование на C# и .NET Core : практическое руководство / Ш. Танвар, А.Д. Воронина ; пер. с англ. А. Д. Ворониной ; ред. В. Н. Черников. - Москва : ДМК Пресс, 2022. - 272 с. - ISBN 978-5-97060-851-7. - Текст : электронный. - URL: https://znanium.ru/catalog/product/2155898 (дата обращения: 19.11.2026). – Режим доступа: по подписке.
Фрагмент текстового слоя документа размещен для индексирующих роботов
Шакти Танвар
Параллельное программирование  
на C# и .NET Core 


Hands-On Parallel 
Programming with 
C# and .NET Core
Build solid enterprise 
software using task parallelism 
and multithreading
Shakti Tanwar
BIRMINGHAM – MUMBAI


Параллельное 
программирование 
на C# и .NET Core
Создание надежного корпоративного 
программного обеспечения 
с использованием параллелизма 
и многопоточности
Шакти Танвар
Москва, 2022


УДК	 004.438.NET
ББК	 32.973.26-018.2
Т18
Танвар Ш.
Т18 	 Параллельное программирование на C# и .NET Core / пер. с англ. А. Д. Во 
ISBN 978-5-97060-851-7
Книга представляет подход к параллельному программированию с учетом 
современных реалий. Информация структурирована таким образом, чтобы она 
легко усваивалась, даже если читатель не обладает специальными знаниями. Рассматриваются общие принципы написания параллельного и асинхронного кода; 
реализация параллелизма данных показана на коротких и простых примерах. 
В конце глав приводятся вопросы для повторения пройденного.
Издание предназначено для программистов C#, которые хотят изучить концепции параллельного программирования и многопоточности, а затем использовать 
полученные знания для приложений, построенных на базе .NET Core. Также оно 
пригодится специалистам, желающим ознакомиться с принципами работы параллельного программирования на современном оборудовании.
УДК  004.438.NET
ББК  32.973.26-018.2
First published in the English language under the title ‘Hands-On Parallel Programming with 
C# 8 and .NET Core 3 – (9781789132410)’. Russian language edition copyright © 2021 by DMK 
Press. All rights reserved.
Все права защищены. Любая часть этой книги не может быть воспроизведена в какой бы то ни было форме и какими бы то ни было средствами без письменного разрешения 
владельцев авторских прав.
ISBN 978-1-78913-241-0 (англ.) 
©  Packt Publishing, 2019
ISBN 978-5-97060-851-7 (рус.) 	
©  Перевод, оформление, издание, 
ДМК Пресс, 2022


Посвящается моим жене и сыну,  
Кирти Танвар и Шашвату Сингх Танвар. 
Они мой жизненно необходимый кислород и стимул,  
вдохновляющий меня на достижение выдающихся успехов


Содержание
От издательства.......................................................................................................14
Об авторе...................................................................................................................15
О переводе................................................................................................................16
О рецензентах..........................................................................................................17
Предисловие.............................................................................................................18
Часть I. ТЕОРЕТИЧЕСКИЕ ОСНОВЫ РАБОТЫ С ПОТОКАМИ, 
МНОГОЗАДАЧНОСТИ И АСИНХРОННОСТИ.........................................22
Глава 1. Введение в параллельное программирование...........................23
Технические требования...........................................................................................24
Подготовка к многоядерным вычислениям...........................................................24
Процессы..................................................................................................................24
Дополнительно об ОС........................................................................................24
Многозадачность....................................................................................................25
Hyper-threading.......................................................................................................25
Классификация Флинна....................................................................................26
Потоки......................................................................................................................27
Типы потоков......................................................................................................27
Многопоточность...................................................................................................30
Класс Thread........................................................................................................31
Класс ThreadPool.................................................................................................35
BackgroundWorker...............................................................................................38
Многопоточность и многозадачность.................................................................41
Сценарии, при которых полезно параллельное программирование.................42
Преимущества и недостатки параллельного программирования......................42
Резюме..........................................................................................................................43
Вопросы........................................................................................................................44
Глава 2. Параллелизм задач................................................................................45
Технические требования...........................................................................................45
Задачи...........................................................................................................................46
Создание и запуск задачи..........................................................................................46
Класс System.Threading.Tasks.Task.......................................................................47
Синтаксис лямбда-выражений........................................................................47
Делегат Action.....................................................................................................47
Делегат.................................................................................................................47


Содержание    7
Метод System.Threading.Tasks.Task.Factory.StartNew........................................48
Синтаксис лямбда-выражений........................................................................48
Делегат Action.....................................................................................................48
Делегат.................................................................................................................48
Метод System.Threading.Tasks.Task.Run..............................................................49
Синтаксис лямбда-выражений........................................................................49
Делегат Action.....................................................................................................49
Делегат.................................................................................................................49
Метод System.Threading.Tasks.Task.Delay...........................................................49
Метод System.Threading.Tasks.Task.Yield............................................................50
Метод System.Threading.Tasks.Task.FromResult<T>...........................................52
Методы System.Threading.Tasks.Task.FromException  
и System.Threading.Tasks.Task.FromException<T>..............................................53
Методы System.Threading.Tasks.Task.FromCanceled  
и System.Threading.Tasks.Task.FromCanceled<T>...............................................53
Результаты выполнения задач..................................................................................54
Отмена задач...............................................................................................................55
Создание метки......................................................................................................55
Создание задач с использованием меток...........................................................56
Опрос состояния метки через свойство IsCancellationRequested...............56
Регистрация отмены запроса с помощью делегата обратного вызова......57
Ожидание выполнения задач...................................................................................58
Task.Wait...................................................................................................................59
Task.WaitAll..............................................................................................................59
Task.WaitAny............................................................................................................60
Task.WhenAll............................................................................................................60
Task.WhenAny..........................................................................................................61
Обработка исключений в задачах............................................................................61
Обработка исключений из одиночных задач.....................................................62
Обработка исключений из нескольких задач....................................................62
Обработка исключений задач с помощью обратного вызова.........................63
Преобразование шаблонов APM в задачи...............................................................64
Преобразование EAP в задачи..................................................................................66
И еще о задачах...........................................................................................................67
Цепочки задач.........................................................................................................67
Продолжение выполнения задач с помощью метода  
Task.ContinueWith..............................................................................................68
Продолжение выполнения задач с помощью  
Task.Factory.ContinueWhenAll и Task.Factory.ContinueWhenAll<T>...........69
Продолжение выполнения задач с помощью  
Task.Factory.ContinueWhenAny и Task.Factory.ContinueWhenAny<T>........69
Родительские и дочерние задачи.........................................................................70
Создание отсоединенной задачи.........................................................................70
Создание присоединенной задачи......................................................................71
Очереди с перехватом работы..................................................................................72
Резюме..........................................................................................................................74


8    Содержание
Глава 3. Реализация параллелизма данных..................................................75
Технические требования...........................................................................................75
От последовательных циклов к параллельным.....................................................75
Метод Parallel.Invoke..............................................................................................76
Метод Parallel.For...................................................................................................78
Метод Parallel.ForEach...........................................................................................79
Степень параллелизма...............................................................................................80
Создание своей стратегии разделения данных.....................................................82
Разделение данных по диапазону.......................................................................83
Разделение данных по блокам.............................................................................83
Отмена циклов............................................................................................................84
Использование метода Parallel.Break..................................................................85
Использование ParallelLoopState.Stop................................................................86
Использование CancellationToken для отмены циклов....................................87
Хранение данных в параллельных циклах.............................................................88
Локальная переменная потока.............................................................................89
Локальная переменная блока данных.................................................................90
Резюме..........................................................................................................................91
Вопросы........................................................................................................................91
Глава 4. Использование PLINQ...........................................................................93
Технические требования...........................................................................................93
LINQ-провайдеры в .NET...........................................................................................93
Создание PLINQ-запросов.........................................................................................94
Знакомство с классом ParallelEnumerable..........................................................94
Наш первый запрос PLINQ....................................................................................95
Сохранение порядка в PLINQ при параллельном исполнении...........................96
Последовательное выполнение с использованием метода AsUnOrdered()......97
Параметры объединения данных в PLINQ..............................................................98
Параметр NotBuffered............................................................................................98
Параметр AutoBuffered..........................................................................................99
Параметр FullyBuffered........................................................................................100
Отправка и обработка исключений с помощью PLINQ......................................102
Объединение параллельных и последовательных запросов LINQ...................104
Отмена запросов PLINQ...........................................................................................104
Недостатки параллельного программирования с помощью PLINQ.................106
Факторы, влияющие на производительность PLINQ (ускорения)....................106
Степень параллелизма.........................................................................................107
Настройка объединения данных........................................................................107
Тип разделения данных.......................................................................................107
Когда нужно сохранять последовательное исполнение в PLINQ?................107
Порядок работы....................................................................................................108
ForAll против вызова ToArray() или ToList().....................................................108
Принудительный параллелизм..........................................................................108
Генерация последовательностей........................................................................108
Резюме........................................................................................................................109
Вопросы......................................................................................................................110


Содержание    9
Часть II. СТРУКТУРЫ ДАННЫХ .NET CORE,  
КОТОРЫЕ ПОДДЕРЖИВАЮТ ПАРАЛЛЕЛИЗМ...................................111
Глава 5. Примитивы синхронизации..............................................................112
Технические требования.........................................................................................112
Что такое примитивы синхронизации?................................................................113
Операции со взаимоблокировкой..........................................................................113
Барьеры доступа к памяти в .NET......................................................................115
Что такое изменение порядка?..........................................................................115
Типы барьеров памяти........................................................................................116
Как избежать изменения порядка.....................................................................117
Введение в примитивы блокировки......................................................................118
Как работает блокировка.....................................................................................118
Состояния потока.................................................................................................118
Блокировка или вращение?................................................................................119
Блокировка, мьютекс и семафор........................................................................120
Lock.....................................................................................................................120
Mutex..................................................................................................................123
Semaphore..........................................................................................................124
ReaderWriterLock...................................................................................................126
Введение в сигнальные примитивы......................................................................126
Thread.Join.............................................................................................................126
EventWaitHandle....................................................................................................128
AutoResetEvent..................................................................................................128
ManualResetEvent.............................................................................................129
WaitHandles............................................................................................................131
Легковесные примитивы синхронизации............................................................134
Slim locks................................................................................................................134
ReaderWriterLockSlim.......................................................................................135
SemaphoreSlim..................................................................................................136
ManualResetEventSlim......................................................................................137
События Barrier и CountDownEvent........................................................................137
Примеры использования Barrier и CountdownEvent.......................................138
SpinWait......................................................................................................................140
SpinLock..................................................................................................................141
Резюме........................................................................................................................142
Вопросы......................................................................................................................142
Глава 6. Использование параллельных коллекций..................................144
Технические требования.........................................................................................144
Введение в параллельные коллекции....................................................................144
Знакомство с IProducerConsumerCollection<T>................................................145
Использование ConcurrentQueue <T>...........................................................145
Производительность Queue<T> в сравнении с ConcurrentQueue<T>.......148
Использование ConcurrentStack <T>.............................................................148
Создание параллельного стека......................................................................149


10    Содержание
Использование ConcurrentBag<T>.................................................................150
Использование BlockingCollection<T>...............................................................151
Создание BlockingCollection<T>.....................................................................151
Сценарий с несколькими производителями и потребителями........................153
Использование ConcurrentDictionary<TKey,TValue>.......................................154
Резюме........................................................................................................................155
Вопросы......................................................................................................................156
Глава 7. Повышение производительности с помощью  
отложенной инициализации.............................................................................157
Технические требования.........................................................................................157
Что такое отложенная инициализация?................................................................157
Введение в System.Lazy<T>......................................................................................160
Логика создания объекта реализуется в конструкторе..................................161
Логика создания объекта передается в качестве делегата в Lazy<T>...........162
Обработка исключений с помощью шаблона отложенной инициализации.....163
Отсутствие исключений в ходе инициализации.............................................163
Случайное исключение при инициализации с кешированием  
исключений...........................................................................................................163
Некешируемые исключения...............................................................................165
Отложенная инициализация с локальным хранилищем потоков....................166
Сокращение издержек при помощи отложенной инициализации..................168
Резюме........................................................................................................................170
Вопросы......................................................................................................................170
Часть III. АСИНХРОННОЕ ПРОГРАММИРОВАНИЕ 
С ИСПОЛЬЗОВАНИЕМ С#..................................................................................172
Глава 8. Введение в асинхронное программирование...........................173
Технические требования.........................................................................................174
Типы выполнения программ..................................................................................174
Синхронное выполнение программ..................................................................174
Асинхронное выполнение программ................................................................176
Случаи использования асинхронного программирования................................177
Написание асинхронного кода...........................................................................177
Использование метода BeginInvoke класса Delegate..................................178
Использование класса Task.............................................................................179
Использование интерфейса IAsyncResult.....................................................179
Когда не следует использовать асинхронное программирование....................181
В базе данных без пула обработки подключений............................................181
Когда важно, чтобы код легко читался и поддерживался..............................181
Для простых и быстрых операций.....................................................................181
Для приложений с большим количеством разделяемых данных.................182
Проблемы, решаемые асинхронным кодом.........................................................182
Резюме........................................................................................................................183
Вопросы......................................................................................................................183


Доступ онлайн
1 049 ₽
В корзину