python asyncio.Lock и рекурсия
В яве такой хрени не встретишь. Но ява старенькая же, а тут новомодная асинхронность, зелёные до тошноты потоки и всё такое. Самое весёлое, что эта зараза даже ошибок не выбрасывает, и отладить такое «зависание» не очень просто.
Deleted
15.12.19 15:05:44 MSK
Я бы добавил проверку locked() на lock, ибо объект Lock не reentrant (фиг знает как оно по-русски).
А в Java он как раз reentrant.
sanwashere ★★
( 15.12.19 15:53:53 MSK )
Последнее исправление: sanwashere 15.12.19 15:54:16 MSK (всего исправлений: 1)
Ответ на: комментарий от sanwashere 15.12.19 15:53:53 MSK
В этом и заморочка. При том, гвидо по ссылке сказал, что это нафиг не надо.
Deleted
( 15.12.19 16:24:26 MSK )
Используй обычные семафоры.
Liz812
( 15.12.19 16:25:32 MSK )
Ответ на: комментарий от Deleted 15.12.19 16:24:26 MSK
В этом и заморочка. При том, гвидо по ссылке сказал, что это нафиг не надо.
Тебе есть что возразить? Он ведь прав, в питоне потоке скорее для галочки. А повторный вход для асинхронщины — это такой специфический случай, что никто не собирается о нем париться. кроме тебя и пары человек из багтрекера. Welcome to Python.
byko3y ★★★★
( 15.12.19 20:42:58 MSK )
Ответ на: комментарий от byko3y 15.12.19 20:42:58 MSK
Он ведь прав, в питоне потоке
То бишь весь asyncio это такая игрушка, и для продакшена негоже оную юзать?
Deleted
( 15.12.19 21:52:52 MSK )
Ответ на: комментарий от Deleted 15.12.19 21:52:52 MSK
Asyncio — это попытка сделать однопоточную поделку хоть как-то юзабельной под нагрузкой. Поскольку питон сам по себе очень медленный, то все функции с питонового кода перекладываются на внешние приложения, как то СУБД, другой сервер, или просто расширения на Си. То есть, по сути питон занимается одним вводом-выводом. Раньше для такого сценария делались многопоточные питоновые приложения, и это работало медленно, потому что сделать эффективный многопоточный диспетчер ввода-вывода весьма непросто, и в том же хаскеле лишь совсем недавно онный доработали до адекватного состояния. Тогда в питоне придумали делать то же, что давным-давно сделали для http-серверов: выкинули к черту все механизмы синхронизации потоков, оставив один поток для событийной обработки ввода-вывода. И о чудо — никаких пятен. Так зачем платить больше?
Ты пытаешься делать событийную обработку, и при этом используешь потоки — это как бы две противоречащие друг другу модели, и Гвидо негодует.
byko3y ★★★★
( 15.12.19 22:48:39 MSK )
Это же ересь. Во вложенном async with лок уже захвачен, какой смысл захватывать его второй раз? Для уродов которые не знают что у них в коде происходит в уродоориентированных языках есть reentrant локи, скрывающие логические ошибки, а тут можете либо исправить код, либо написать reentrant лок из 2 строчек, в любом случае пострадаете, заслуженно.
slovazap ★★★★★
( 15.12.19 22:50:29 MSK )
Ответ на: комментарий от byko3y 15.12.19 22:48:39 MSK
Эта блокировка не поддерживает многопоточность. И в примере всего один поток.
Deleted
( 15.12.19 23:02:01 MSK )
Ответ на: комментарий от slovazap 15.12.19 22:50:29 MSK
О, адепты подтянулись. Кроме словоизвержения есть шо сказать?
Deleted
( 15.12.19 23:02:05 MSK )
Ответ на: комментарий от slovazap 15.12.19 22:50:29 MSK
Для уродов которые не знают что у них в коде происходит в уродоориентированных языках есть reentrant локи, скрывающие логические ошибки, а тут можете либо исправить код, либо написать reentrant лок из 2 строчек, в любом случае пострадаете, заслуженно.
Не согласен. В большом приложении с неявными вызовами функций повторно взять блокировку очень просто, а спроектировать приложение для исключения такой ситуации — сложно.
Но вообще, асинхронная архитектура подразумевает снижение уровня вложенности вызовов с переходом на линейную последовательность вызовов.
byko3y ★★★★
( 15.12.19 23:02:46 MSK )
Ответ на: комментарий от Deleted 15.12.19 23:02:01 MSK
Эта блокировка не поддерживает многопоточность. И в примере всего один поток.
Эм-м-м. так и зачем она нужна? Чтобы было о чем поговорить, попивая пивцо?
byko3y ★★★★
( 15.12.19 23:03:29 MSK )
Ответ на: комментарий от byko3y 15.12.19 23:03:29 MSK
Для консистентности доступа к обектам, особенно на запись. Не всегда легко разруливать изменения сложных объектов без простой блокировки.
Кроме того, гвидо её создал, значит тоже видит некие кейсы применения. Но оставил грабли.
Deleted
( 15.12.19 23:11:29 MSK )
Ответ на: комментарий от Deleted 15.12.19 23:11:29 MSK
Не всегда легко разруливать изменения сложных объектов без простой блокировки
Делай это синхронно. Без блокировки.
Кроме того, гвидо её создал, значит тоже видит некие кейсы применения
Он сам и пишет, что она нужна для случаев с вызовами параллельных зеленых потоков.
byko3y ★★★★
( 15.12.19 23:17:30 MSK )
Последнее исправление: byko3y 15.12.19 23:18:10 MSK (всего исправлений: 1)
Ответ на: комментарий от byko3y 15.12.19 23:17:30 MSK
Делай это синхронно. Без блокировки.
Кое-кто издевается, как я погляжу 8).
Он сам и пишет, что она нужна для случаев с вызовами параллельных зеленых потоков.
Это и есть тот случай. Технически это один поток, но разные корутины (на которых сделаны зелёные потоки).
Асинхронный доступ к файлам (C#)
Для доступа к файлам можно использовать функцию Async. При использовании функции Async вы можете вызывать асинхронные методы без использования обратных вызовов или разделения вашего кода на множество методов или лямбда-выражений. Для выполнения последовательного кода асинхронно просто вызовите асинхронный метод вместо синхронного метода и добавьте несколько ключевых слов в код.
Можно рассмотреть следующие причины для добавления асинхронности для вызовов для доступа к файлам.
- Асинхронность делает приложения пользовательского интерфейса более отзывчивыми, потому что поток пользовательского интерфейса, который запускает операцию, может продолжать выполнять и другую работу. Если поток пользовательского интерфейса должен выполнять код, который занимает много времени (например, более 50 миллисекунд), пользовательский интерфейс можно приостановить до тех пор, пока не будет завершен ввод-вывод, и затем пользовательский интерфейс сможет снова обрабатывать ввод с клавиатуры, мыши и другие события.
- Асинхронность улучшает масштабируемость ASP.NET и других серверных приложений за счет уменьшения необходимости использования потоков. Если приложение использует выделенный поток на ответ и тысяча запросов приходит одновременно, тысяча потоков не потребуется. Асинхронные операции часто не нуждаются в пользовании потоком во время ожидания. Они пользуются существующим потоком завершения ввода-вывода короткое время в конце.
- Задержка операции доступа к файлу может быть очень низкой при текущих условиях, но может значительно увеличиться в будущем. Например, файл может быть перемещен на сервер через Интернет.
- Добавленные издержки при использовании функции Async являются малыми.
- Асинхронные задачи могут легко выполняться параллельно.
Использование соответствующих классов
В простых примерах в этом разделе демонстрируются File.WriteAllTextAsync и File.ReadAllTextAsync. Для точного управления операциями файлового ввода-вывода используйте FileStream класс , который имеет параметр, который вызывает асинхронные операции ввода-вывода на уровне операционной системы. С помощью этого параметра можно избежать блокирования пула потоков во многих случаях. Чтобы включить этот параметр, необходимо добавить в вызов конструктора аргумент useAsync=true или options=FileOptions.Asynchronous .
Этот параметр нельзя использовать с классами StreamReader и StreamWriter, если вы открываете их напрямую (указав путь к файлу). При этом параметр можно использовать, если им предоставлен Stream, открытый классом FileStream. Асинхронные вызовы выполняются быстрее в приложениях пользовательского интерфейса, даже если поток в пуле потоков блокирован, поскольку поток пользовательского интерфейса не блокирован во время ожидания.
Запись текста
Следующие примеры записывают текст в файл. На каждой точке await происходит немедленный выход из метода. После завершения файлового ввода-вывода метод возобновляет работу с пункта, следующего за await. Модификатор async в определении методов требует наличия await в теле метода.
Простой пример
public async Task SimpleWriteAsync()
Пример конечного элемента управления
public async Task ProcessWriteAsync() < string filePath = "temp.txt"; string text = $"Hello World"; await WriteTextAsync(filePath, text); > async Task WriteTextAsync(string filePath, string text)
Первоначальная строка с оператором await sourceStream.WriteAsync(encodedText, 0, encodedText.Length); является сокращенной формой записи двух следующих операторов:
Task theTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length); await theTask; Первый оператор возвращает задачу и вызывает запуск обработки файла. Вторая строка с await немедленно оставляет метод и возвращается в другую задачу. При окончании обработки файла выполнение возвращается в точку выполнения, которая следует за await.
Чтение текста
Следующий пример считывает текст из файла.
Простой пример
public async Task SimpleReadAsync()
Пример конечного элемента управления
Текст добавляется в буфер обмена, а затем, в данном случае, помещается в StringBuilder. В отличие от предыдущего примера await выдаёт в результате значение. Метод ReadAsync возвращаетInt32<>Task , поэтому вычисление await создает Int32 значение numRead после завершения операции. Дополнительные сведения см. в разделе Асинхронные типы возвращаемых значений (C#).
public async Task ProcessReadAsync() < try < string filePath = "temp.txt"; if (File.Exists(filePath) != false) < string text = await ReadTextAsync(filePath); Console.WriteLine(text); >else < Console.WriteLine($"file not found: "); > > catch (Exception ex) < Console.WriteLine(ex.Message); >> async Task ReadTextAsync(string filePath) < using var sourceStream = new FileStream( filePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 4096, useAsync: true); var sb = new StringBuilder(); byte[] buffer = new byte[0x1000]; int numRead; while ((numRead = await sourceStream.ReadAsync(buffer, 0, buffer.Length)) != 0) < string text = Encoding.Unicode.GetString(buffer, 0, numRead); sb.Append(text); >return sb.ToString(); > Параллельный асинхронный ввод-вывод
В следующем примере показана параллельная обработка при записи 10 текстовых файлов.
Простой пример
public async Task SimpleParallelWriteAsync() < string folder = Directory.CreateDirectory("tempfolder").Name; IListwriteTaskList = new List(); for (int index = 11; index .txt"; string filePath = $"/"; string text = $"In file "; writeTaskList.Add(File.WriteAllTextAsync(filePath, text)); > await Task.WhenAll(writeTaskList); > Пример конечного элемента управления
Для каждого файла метод WriteAsync возвращает задачу, которая затем добавляется в список задач. Оператор await Task.WhenAll(tasks); существует и возобновляется в методе, как только завершается обработка файла для всех задач.
Пример закрывает все экземпляры FileStream в блоке finally после завершения всех задач. Если бы вместо этого каждый FileStream был бы создан в операторе using , то FileStream можно было бы удалить до завершения задачи.
Любое увеличение производительности зависит почти полностью от параллельной, а не асинхронной обработки. Преимущества асинхронности в том, что она не привязана к количеству потоков и не связана с потоком пользовательского интерфейса.
public async Task ProcessMultipleWritesAsync() < IListsourceStreams = new List(); try < string folder = Directory.CreateDirectory("tempfolder").Name; IListwriteTaskList = new List(); for (int index = 1; index .txt"; string filePath = $"/"; string text = $"In file "; byte[] encodedText = Encoding.Unicode.GetBytes(text); var sourceStream = new FileStream( filePath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 4096, useAsync: true); Task writeTask = sourceStream.WriteAsync(encodedText, 0, encodedText.Length); sourceStreams.Add(sourceStream); writeTaskList.Add(writeTask); > await Task.WhenAll(writeTaskList); > finally < foreach (FileStream sourceStream in sourceStreams) < sourceStream.Close(); >> > При использовании методов WriteAsync и ReadAsync можно указать CancellationToken, который позволяет отменить операцию в середине потока. Подробные сведения см. в статье Отмена в управляемых потоках.
См. также раздел
- Асинхронное программирование с использованием ключевых слов Async и Await (C#)
- Типы возвращаемых значений асинхронных операций (C#)
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
Threads. Lock types. lock. Async/await. Task. Parallel
lock: синхронизирует потоки, запрещает доступ к lock блоку из нескольких потоков.
Threads
Поток (thread) представляет собой независимую последовательность инструкций в программе. К примеру, во время ввода какого-то кода C# в окне редактора Visual Studio проводится анализ на предмет различных синтаксических ошибок. Этот анализ осуществляется отдельным фоновым потоком. Один поток ожидает ввода данных пользователем, а другой в это время выполняет в фоновом режиме некоторый анализ. Третий поток может сохранять записываемые данные во временный файл, а четвертый — загружать дополнительные данные из Интернета.
Различают две разновидности многозадачности: на основе процессов и на основе потоков. В связи с этим важно понимать отличия между ними. Процесс отвечает за управление ресурсами, к числу которых относится виртуальная память и дескрипторы Windows, и содержит как минимум один поток. Наличие хотя бы одного потока является обязательным для выполнения любой программы. Поэтому многозадачность на основе процессов — это средство, благодаря которому на компьютере могут параллельно выполняться две программы и более.
Поток может находиться в одном из нескольких состояний. В целом, поток может быть выполняющимся; готовым к выполнению, как только он получит время и ресурсы ЦП; приостановленным, т.е. временно не выполняющимся; возобновленным в дальнейшем; заблокированным в ожидании ресурсов для своего выполнения; а также завершенным, когда его выполнение окончено и не может быть возобновлено.
В среде .NET Framework определены две разновидности потоков: приоритетный и фоновый.
Любая многопоточная программа должна содержать:
using System.Threading;
Пространство имен System.Threading содержит различные типы, позволяющие создавать многопоточные приложения. Пожалуй, главным среди них является класс Thread, поскольку он представляет отдельный поток. Чтобы программно получить ссылку на поток, выполняемый конкретным его экземпляром, просто вызовите статическое свойство Thread.CurrentThread.
На платформе .NET не существует прямого соответствия “один к одному” между доменами приложений (AppDomain) и потоками. Фактически определенный AppDomain может иметь несколько потоков, выполняющихся в каждый конкретный момент времени. Более того, конкретный поток не привязан к одному домену приложений на протяжении своего времени существования. Потоки могут пересекать границы доменов приложений, когда это вздумается планировщику Windows и CLR.
Хотя активные потоки могут пересекать границы AppDomain, каждый поток в каждый конкретный момент времени может выполняться только внутри одного домена приложений (другими словами, невозможно, чтобы один поток работал в более чем одном домене приложений сразу). Чтобы программно получить доступ к AppDomain, в котором работает текущий поток, вызовите статический метод Thread.GetDomain().
Единственный поток также в любой момент может быть перемещен в определенный контекст, и он может перемещаться в пределах нового контекста по прихоти CLR. Для получения текущего контекста, в котором выполняется поток, используйте статическое свойство Thread.CurrentContext.
За перемещение потоков между доменами приложений и контекстами отвечает CLR.
Потоки переднего плана (foreground threads) обеспечивают предохранение текущего приложения от завершения. Среда CLR не остановит приложение (что означает выгрузку текущего домена приложения) до тех пор, пока не будут завершены все потоки переднего плана.
Фоновые потоки (background threads) воспринимаются средой CLR как расширяемые пути выполнения, которые в любой момент времени могут игнорироваться (даже если они в текущее время заняты выполнением некоторой части работы). Таким образом, если все потоки переднего плана прекращаются, то все фоновые потоки автоматически уничтожаются при выгрузке домена приложения.
Важно отметить, что потоки переднего плана и фоновые потоки — это не синонимы первичных и рабочих потоков. По умолчанию каждый поток, создаваемый через метод Thread.Start(), автоматически становится потоком переднего плана. Это означает, что домен приложения не выгрузится до тех пор, пока все потоки выполнения не завершат свою часть работы. В большинстве случаев именно такое поведение и нужно.
Чтобы создать фоновый поток необходимо установить свойство IsBackground в true.
Приоритеты потоков
Как упоминалось ранее, за планирование потоков к запуску отвечает операционная система. На этот процесс планирования можно влиять, назначая потокам приоритеты. Прежде чем менять приоритет, нужно разобраться в том, как функционирует планировщик потоков. Операционная система планирует выполнение потоков на основе их приоритетов. Поток с наивысшим приоритетом начинает выполняться в ЦП первым. Поток прекращает выполнение и освобождает ЦП, если ему требуется ожидание какого-то ресурса.
Есть несколько причин для перехода потока в режим ожидания. Например, это может происходить из-за получения команды на засыпание, из-за необходимости ожидать завершение дисковых операций ввода-вывода, поступление сетевого пакета и т.п. Если поток не освобождает ЦП самостоятельно, его вытесняет планировщик потоков. Если поток имеет выделенный квант времени, он может использовать ЦП непрерывно.
Если выполняется несколько потоков с одинаковым приоритетом, каждый из которых ожидает получения доступа к ЦП, планировщик потоков применяет алгоритм кругового обслуживания, предоставляя этим потокам доступ к ЦП по очереди. В случае вытеснения поток помещается в конец очереди.
В классе Thread базовый приоритет потока устанавливается в свойстве Priority. Допустимые значения определены в перечислении ThreadPriority. Эти значения представляют различные уровни приоритета и выглядят следующим образом: Highest, AboveNormal, Normal, BelowNormal и Lowest.
Класс Interlocked
Класс Interlocked позволяет создавать простые операторы для атомарных операций с переменными. Например, операция i++ не является безопасной в отношении потоков. Она подразумевает извлечение значения из памяти, увеличение этого значения на 1 и его обратное сохранение в памяти. Такие операции могут прерываться планировщиком потоков. Класс Interlocked предоставляет методы, позволяющие выполнять инкремент, декремент, обмен и считывание значений в безопасной к потокам манере.
CompareExchange() — Безопасно проверяет два значения на эквивалентность. Если они эквивалентны, изменяет одно из значений на третье
Decrement() — Безопасно уменьшает значение на 1
Exchange() — Безопасно меняет два значения местами
Increment() — Безопасно увеличивает значение на 1
Класс Monitor
Компилятор C# преобразует оператор lock в код, использующий класс Monitor. Например, показанный ниже оператор lock:
lock (obj)
// синхронизированная область для obj
>
будет преобразован в код, который вызывает метод Enter() и ожидает, пока поток не получит объектную блокировку. В каждый момент времени только один поток может быть владельцем объектной блокировки. После получения блокировки поток сможет входить в синхронизируемый раздел. Метод Exit() класса Monitor позволяет снимать блокировку.
Компилятор помещает вызов метода Exit() в обработчик finally блока try, чтобы блокировка снималась даже в случае генерации исключения:
Monitor.Enter(obj);
try
// синхронизированная область для obj
>
finally
Monitor.Exit(obj);
>
Класс Monitor обладает одним важным преимуществом по сравнению с оператором lock в C#: он позволяет добавлять значение тайм-аута для ожидания получения блокировки. Таким образом, вместо того, чтобы ожидать блокировку до бесконечности, можно вызвать метод TryEnter и передать в нем значение тайм-аута, указывающее, сколько максимум времени должно ожидаться получение блокировки.
Когда блокировка obj получена, метод TryEnter() устанавливает булевский параметр ref в true и производит синхронизированный доступ к состоянию, охраняемому объектом obj. Если obj блокируется другим потоком на протяжении более 500 миллисекунд, то TryEnter() устанавливает переменную lockTaken в false и поток больше не ожидает, а используется для выполнения другой работы. Возможно, позже поток попытается получить блокировку еще раз.
Атрибут [Synchronization]
Последний из примитивов синхронизации, которые здесь рассматриваются — это атрибут [Synchronization], который является членом пространства имен System.Runtime.Remoting.Contexts. Этот атрибут уровня класса эффективно блокирует весь код членов экземпляра объекта, обеспечивая безопасность в отношении потоков.
Когда среда CLR размещает объекты, снабженные атрибутами [Synchronization], она помещает объект в контекст синхронизации. Объекты, которые не должны выходить за границы контекста, должны наследоваться от ContextBoundObject. Поэтому, чтобы сделать класс MyThread безопасным к потокам (без явного написания кода внутри членов класса), необходимо модифицировать его следующим образом:
using System.Runtime.Remoting.Contexts;
.
// Все методы MyThread теперь безопасны к потокам!
[Synchronization]
public class MyThread : ContextBoundObject
public void ThreadNumbers()
>
В некоторых отношениях этот подход выглядит как “ленивый” способ написания безопасного к потокам кода, учитывая, что не приходится углубляться в детали относительно того, какие именно аспекты типа действительно манипулируют чувствительными к потокам данными. Однако главный недостаток этого подхода состоит в том, что даже если определенный метод не использует чувствительные к потокам данные, CLR будет по-прежнему блокировать вызовы этого метода. Очевидно, что это приведет к деградации общей функциональности типа, поэтому используйте такую технику с осторожностью.
Методы Wait(), Pulse() и PulseAll
Рассмотрим следующую ситуацию. Поток T выполняется в кодовом блоке lock, и ему требуется доступ к ресурсу R, который временно недоступен. Что же тогда делать потоку T? Если поток T войдет в организованный в той или иной форме цикл опроса, ожидая освобождения ресурса R, то тем самым он свяжет соответствующий объект, блокируя доступ к нему других потоков. Это далеко не самое оптимальное решение, поскольку оно лишает отчасти преимуществ программирования для многопоточной среды.
Более совершенное решение заключается в том, чтобы временно освободить объект и тем самым дать возможность выполняться другим потокам. Такой подход основывается на некоторой форме сообщения между потоками, благодаря которому один поток может уведомлять другой о том, что он заблокирован и что другой поток может возобновить свое выполнение. Сообщение между потоками организуется в C# с помощью методов Wait(), Pulse() и PulseAll().
Методы Wait(), Pulse() и PulseAll() определены в классе Monitor и могут вызываться только из заблокированного фрагмента блока. Они применяются следующим образом. Когда выполнение потока временно заблокировано, он вызывает метод Wait(). В итоге поток переходит в состояние ожидания, а блокировка с соответствующего объекта снимается, что дает возможность использовать этот объект в другом потоке. В дальнейшем ожидающий поток активизируется, когда другой поток войдет в аналогичное состояние блокировки, и вызывает метод Pulse() или PulseAll().
При вызове метода Pulse() возобновляется выполнение первого потока, ожидающего своей очереди на получение блокировки. А вызов метода PulseAll() сигнализирует о снятии блокировки всем ожидающим потокам.
Mutex
Класс Mutex (mutual exclusion — взаимное исключение или мьютекс) является одним из классов в .NET Framework, позволяющих обеспечить синхронизацию среди множества процессов. Он очень похож на класс Monitor тем, что тоже допускает наличие только одного владельца. Только один поток может получить блокировку и иметь доступ к защищаемым мьютексом синхронизированным областям кода.
В конструкторе класса Mutex указывается, должен ли мьютексом изначально владеть вызывающий поток, и его имя. Кроме того, конструктор позволяет получить информацию о том, существует ли уже такой класс.
Мьютекс представляет собой взаимно исключающий синхронизирующий объект. Это означает, что он может быть получен потоком только по очереди. Мьютекс предназначен для тех ситуаций, в которых общий ресурс может быть одновременно использован только в одном потоке. Допустим, что системный журнал совместно используется в нескольких процессах, но только в одном из них данные могут записываться в файл этого журнала в любой момент времени. Для синхронизации процессов в данной ситуации идеально подходит мьютекс.
Semaphore
Семафор подобен мьютексу, за исключением того, что он предоставляет одновременный доступ к общему ресурсу не одному, а нескольким потокам. Поэтому семафор пригоден для синхронизации целого ряда ресурсов. Семафор управляет доступом к общему ресурсу, используя для этой цели счетчик. Если значение счетчика больше нуля, то доступ к ресурсу разрешен. А если это значение равно нулю, то доступ к ресурсу запрещен. С помощью счетчика ведется подсчет количества разрешений. Следовательно, для доступа к ресурсу поток должен получить разрешение от семафора.
Обычно поток, которому требуется доступ к общему ресурсу, пытается получить разрешение от семафора. Если значение счетчика семафора больше нуля, то поток получает разрешение, а счетчик семафора декрементируется. В противном случае поток блокируется до тех пор, пока не получит разрешение. Когда же потоку больше не требуется доступ к общему ресурсу, он высвобождает разрешение, а счетчик семафора инкрементируется. Если разрешения ожидает другой поток, то он получает его в этот момент. Количество одновременно разрешаемых доступов указывается при создании семафора. Так, если создать семафор, одновременно разрешающий только один доступ, то такой семафор будет действовать как мьютекс.
Семафоры особенно полезны в тех случаях, когда общий ресурс состоит из группы или пула ресурсов. Например, пул ресурсов может состоять из целого ряда сетевых соединений, каждое из которых служит для передачи данных. Поэтому потоку, которому требуется сетевое соединение, все равно, какое именно соединение он получит. В данном случае семафор обеспечивает удобный механизм управления доступом к сетевым соединениям.
Семафор реализуется в классе System.Threading.Semaphore, у которого имеется несколько конструкторов. Ниже приведена простейшая форма конструктора данного класса:
public Semaphore(int initialCount, int maximumCount)
Асинхронные делегаты
Наиболее простым способом для создания потока является определение делегата и его вызов асинхронным образом. Делегаты могут исполнять роль безопасных для типов ссылок на методы. Помимо этого класс Delegate поддерживает и возможность асинхронного вызова этих методов. Для решения поставленной задачи он создает “за кулисами” отдельный поток.
При создании следующего делегата
public delegate int BinaryOp(int x, int y);
создаётся примерно такой класс:
public sealed class BinaryOp : System.MulticastDelegate
<
public BinaryOp(object target, uint functionAddress);
public void Invoke(int x, int y);
public IAsyncResult Beginlnvoke(int x, int y, AsyncCallback cb, object state);
public int Endlnvoke(IAsyncResult result);
>
Async/await. Task. Parallel
В .NET 4.5 во фреймворк были добавлены два новых ключевых слова async и await, цель которых — упростить написание асинхронного кода. Вместе с функциональностью задач Task они составляют основу новой модели асинхронного программирования в .NET, которая называется Task-based Asynchronous Pattern.
Ключевое слово async указывает, что метод или лямбда-выражение являются асинхронными. А оператор await применяется к задаче в асинхронных методах, чтобы приостановить выполнение метода до тех пор, пока эта задача не завершится. При этом выполнение потока, в котором был вызван асинхронный метод, не прерывается.
Parallel — класс для запуска параллельных операций. Работает с помощью Task. Предоставляет поддержку параллельных циклов и областей.
Task
В библиотеке классов .NET задача представлена специальным классом — классом Task, который находится в пространстве имен System.Threading.Tasks. Данный класс описывает отдельную задачу, которая запускается в отдельном потоке. Хотя при желании ее также можно запускать синхронно в текущем потоке.
Класс Task в качестве параметра принимает делегат Action. Этот делегат имеет определение public delegate void Action() , то есть указывает на метод, который не имеет параметров и который не возвращает никакого значения.
Для создания и последующего запуска задачи можно использовать конструктор класса Task и затем его метод Start, либо класс TaskFactory.
Способы вызова Task.
Lock files async что это
Асинхронный метод может содержать множество выражений await. Когда система встречает в блоке кода оператор await, то выполнение в асинхронном методе останавливается, пока не завершится асинхронная задача. После завершения задачи управление переходит к следующему оператору await и так далее. Это позволяет вызывать асинхронные задачи последовательно в определенном порядке. Например:
await PrintAsync("Hello C#"); await PrintAsync("Hello World"); await PrintAsync("Hello METANIT.COM"); async Task PrintAsync(string message) < await Task.Delay(2000); // имитация продолжительной операции Console.WriteLine(message); >
Консольный вывод данной программы:
Hello C# Hello World Hello METANIT.COM
То есть мы видим, что вызовы PrintAsync выполняются последовательно в том порядке, в котором они определены в коде. Каждая задача выполняется как минимум 2 секунды, соответственно общее время выполнения трех задач будет как минимум 6 секунд. И в данном случае вывод строго детерминирован.
Нередко такая последовательность бывает необходима, если одна задача зависит от результатов другой.
Однако это не всегда необходимо. В подобном случае мы можем сразу запустить все задачи параллельно и применить оператор await там, где необходимо гарантировать завершение выполнения задачи, например, в самом конце программы.
// определяем и запускаем задачи var task1 = PrintAsync("Hello C#"); var task2 = PrintAsync("Hello World"); var task3 = PrintAsync("Hello METANIT.COM"); // ожидаем завершения задач await task1; await task2; await task3; async Task PrintAsync(string message) < await Task.Delay(2000); // имитация продолжительной операции Console.WriteLine(message); >
В этом случае все задачи запускаются и выполняются параллельно, соответственно общее время выполнения будет меньше 6 секунд, а консольный вывод программы недетерминирован. Например, он может быть следующим:
Hello METANIT.COM Hello C# Hello World
Однако .NET позволяет упростить отслеживание выполнения набора задач с помощью метода Task.WhenAll . Этот метод принимает набор асинхронных задач и ожидает завершения всех этих задач. Этот метод является аналогом статического метода Task.WaitAll() , однако предназначен непосредственно для асинхронных методов и позволяет применять оператор await:
// определяем и запускаем задачи var task1 = PrintAsync("Hello C#"); var task2 = PrintAsync("Hello World"); var task3 = PrintAsync("Hello METANIT.COM"); // ожидаем завершения всех задач await Task.WhenAll(task1, task2, task3); async Task PrintAsync(string message) < await Task.Delay(2000); // имитация продолжительной операции Console.WriteLine(message); >
Вначале запускаются три задачи. Затем Task.WhenAll создает новую задачу, которая будет автоматически выполнена после выполнения всех предоставленных задач, то есть задач task1, task2, task3. А с помощью оператора await ожидаем ее завершения.
Если нам надо дождаться, когда будет выполнена хотя бы одна задача из некоторого набора задач, то можно применять метод Task.WhenAny() . Это аналог метода Task.WaitAny() — он завершает выполнение, когда завершается хотя бы одна задача. Но для ожидания выполнения к Task.WhenAny() применяется оператор await:
// определяем и запускаем задачи var task1 = PrintAsync("Hello C#"); var task2 = PrintAsync("Hello World"); var task3 = PrintAsync("Hello METANIT.COM"); // ожидаем завершения хотя бы одной задачи await Task.WhenAny(task1, task2, task3); async Task PrintAsync(string message) < await Task.Delay(new Random().Next(1000, 2000)); // имитация продолжительной операции Console.WriteLine(message); >
Получение результата
Задачи, передаваемые в Task.WhenAll и Task.WhenAny , могут возвращать некоторое значение. В этом случае из методов Task.WhenAll и Task.WhenAny можно получить массив, который будет содержать результаты задач:
// определяем и запускаем задачи var task1 = SquareAsync(4); var task2 = SquareAsync(5); var task3 = SquareAsync(6); // ожидаем завершения всех задач int[] results = await Task.WhenAll(task1, task2, task3); // получаем результаты: foreach (int result in results) Console.WriteLine(result); async Task SquareAsync(int n)
В данном случае метод Square возвращает число int — квадрат передаваемого в метод числа. И переменная results будет содержать результат вызова Task.WhenAll — по сути результаты всех трех запущенных задач. Поскольку все передаваемые в Task.WhenAll задачи возвращают int, то соответственно результат Task.WhenAll будет представлять массив значений int.
Также после завершения задачи ее результат можно получить стандартным образом через свойство Result:
// определяем и запускаем задачи var task1 = SquareAsync(4); var task2 = SquareAsync(5); var task3 = SquareAsync(6); await Task.WhenAll(task1, task2, task3); // получаем результат задачи task2 Console.WriteLine($»task2 result: «); // task2 result: 25 async Task SquareAsync(int n)