Wild Async .NET world: AID Kit for boy-scouts

Wild Async
.NET world
By Vladimir Garbar
.NET Meetup
Play
hys-enterprise.com

My experience
.NET Developer
Team Lead @ HYS Enterprise
.NET Meetup

HYS Enterprise is a Dutch software
development company with more than
200 talented engineers from all over
the world hys-enterprise.com
UkraineNetherlands

Wild Async .NET world
AID Kit for boy scouts
.NET Meetup

План
1. Общие понятия
2. Async + Await
3. Практики
.NET Meetup

Общие понятия
.NET Meetup

Конкурентность
Выполнение нескольких действий в одно и то же время
.NET Meetup

Конкурентность
Полезность:
- В любой ситуации, когда приложение должно делать что-то одно во
время работы над чем-то другим.
- Для конечного пользователя, чтобы реагировать на ввод данных
пользователем во время записи в базу данных.
- Серверные приложения используют конкурентность для реакции на
второй запрос в ходе завершения первого запроса.
.NET Meetup

Многопоточность
Форма конкурентности, использующая несколько
потоков выполнения
.NET Meetup

Параллельная обработка
Выполнение большого объема работы за счет
распределения ее между несколькими потоками,
выполняемыми одновременно
.NET Meetup

Асинхронное программирование
Разновидность конкурентности, использующая
обещания или обратные вызовы для предотвращения
создания лишних потоков
.NET Meetup

Преимущества
.NET Meetup

● Уменьшает сложность
● Улучшает читаемость
.NET Meetup

● Производительность?
.NET Meetup

● Производительность?
● Масштабируемость!
.NET Meetup

Масштабируемость
● Горизонтальная
● Вертикальная
.NET Meetup

Горизонтальная масштабируемость
Добавление количества серверов:
- RESTful
- Распределенные базы данных
- Кэширование данных
- Отсутствие сессии
.NET Meetup

Вертикальная масштабируемость
Улучшение качеств текущих серверов:
- Больше RAM
- Быстрые HDD
- Больше CPU Cores
- Более оптимальное использование ресурсов
- Оптимальное использование потоков
- Освобождение потока как можно скорее
.NET Meetup

Параллельная обработка
Использует потоки, которые иначе бы простаивали
.NET Meetup

Асинхронное программирование
Освобождает потоки
.NET Meetup

Подводные камни
● Проблемы с общим доступом
● Восстановление контекста
● Deadlock
● Сложно использовать
.NET Meetup

Async
● Добавляется в объявление метода.
● Разрешает использование ключевого слова await внутри этого метода.
● Дает инструкцию компилятору сгенерировать для этого метода
конечный автомат
.NET Meetup

Await
● Выполняет асинхронное ожидание по своему аргументу. Сначала
проверяет, завершилась ли операция: если да, то метод продолжает
выполняться синхронно.
● В противном случае await приостанавливает async-метод и возвращает
незавершенную задачу.
● Когда операция завершится позднее, метод async продолжает
выполнение.
.NET Meetup

Async-метод
Может рассматриваться как состоящий из нескольких синхронных частей,
разделенных командами await.
.NET Meetup

Async-метод
Первая синхронная часть выполняется в потоке, который вызвал метод.
Все синхронные части пытаются возобновить продолжение в исходном
контексте.
Если вызвать метод DoSomethingAsync из UI-потока, каждая из его
синхронных частей будет выполняться в этом UI-потоке, но если вызвать
его из потока из пула потоков, то каждая из синхронных частей будет
выполняться в любом потоке из пула потоков.
.NET Meetup

Синхронизация контекста
● UI thread
● ASP.NET
.NET Meetup

Взаимоблокировка
.NET Meetup
void Deadlock()
{
Task task = WaitAsync();
// Синхронное блокирование с
ожиданием завершения async метода.
task.Wait();
}
async Task WaitAsync()
{
// await сохранит текущий контекст
await Task.Delay(TimeSpan.FromSeconds(1));
// попытается возобновить метод в этой точке с
этим контекстом.
}

● ConfigureAwait(false)
● await
.NET Meetup

Взаимоблокировка: Решение
.NET Meetup
void Deadlock()
{
Task task = WaitAsync();
// Синхронное блокирование с
ожиданием завершения async метода.
task.Wait();
}
{
await Task.Delay(TimeSpan.FromSeconds(1))
.ConfigureAwait(false);
}

Взаимоблокировка: Лучшее
.NET Meetup
async void Deadlock()
{
Task task = await WaitAsync();
}
{
// await сохранит текущий контекст
// попытается возобновить метод в этой точке с
этим контекстом.
}

Хорошей практикой считается вызывать ConfigureAwait в базовых
“библиотечных” методах и возобновлять контекст только тогда, когда
потребуется - в ваших внешних методах “пользовательского интерфейса”.
.NET Meetup

ConfigureAwait(false) конфигурирует Task так, что возвращение из await не
обязательно должно выполняться в вызывающем контексте.
Использовалось для избегания Deadlocks.
И для того, чтобы не ожидать вызывающий контекст.
.NET Meetup

ASP.NET Core не имеет синхронизации контекста
- Используется Thread pool
- Улучшает производительность
- Легче писать async code. Не ответственность разработчика
- Task.Result больше не приводит к Deadlock,
но приводит к блокировке вызывающего потока
.NET Meetup

ConfigureAwait(false) больше не требуется для .NET Core
Но желательно для .NET Standard 2.0, который может работать под .NET
Framework
.NET Meetup

Синхронный код + асинхронный
.NET Meetup

.NET Meetup
async Task<string> DownloadStringAsync(HttpClient client, string uri)
{
return await client.GetStringAsync(uri);
}

.NET Meetup
string DownloadString(HttpClient client, string uri)
{
return await client.GetStringAsync(uri); // Error!
}

.NET Meetup
{
return client.GetStringAsync(uri).Result;
}

.NET Meetup
{
return client.GetStringAsync(uri).GetAwaiter().GetResult();
}

.NET Meetup
Task<string> DownloadStringAsync(HttpClient client, string uri)
{
return client.GetStringAsync(uri);
}

.NET Meetup
async Task<string> DownloadStringAsync(HttpClient client, string uri)
{
try
{
}
catch(Exception)
{
// обработаем ошибку
}
}

.NET Meetup
Task<string> DownloadStringAsync(HttpClient client, string uri)
{
try
{
return client.GetStringAsync(uri);
}
catch(Exception)
{
// сюда не попадем :(
}
}

.NET Meetup
Task DoSomethingAsync()
{
return Task.CompletedTask;
}

.NET Meetup
Task<int> GetValueAsync()
{
return Task.FromResult(200);
}

.NET Meetup
Task<int> GetValueAsync(CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
return Task.FromCanceled<int>(cancellationToken);
return Task.FromResult(200);
}

.NET Meetup
Task<T> ExceptionAsync<T>()
{
return Task.FromException<T>(new NotImplementedException());
}

.NET Meetup
Task DoSomethingAsync()
{
try
{
DoSomething();
return Task.CompletedTask;
}
catch (Exception ex)
{
return Task.FromException(ex);
}
}

Async
Async метод возвращает:
● void
● Task, Task<TResult>
● ValueTask, ValueTask<T>
● IAsyncEnumerable<T>, IAsyncEnumerator<T>
.NET Meetup

async void
● Только для event handlers
● Тяжело обрабатывать ошибки
● Сложно тестировать
● Нелегко оповещать вызывающий код о статусе своего выполнения
.NET Meetup

ValueTask
● Cокращает затраты памяти, если результат в основном является
синхронным.
● Например, если результат может быть прочитан из кэша в памяти.
.NET Meetup

ValueTask
.NET Meetup
async ValueTask<int> GetOrderAsync()
{
if (_cachedOrder != 0)
return _cachedOrder;
_cachedOrder = await GetOrderFromStorageAsync();
return _cachedOrder;
}

ValueTask: недостатки
● ValueTask или ValueTask<T> может ожидаться только один раз
● Можно вызвать AsTask только один раз.
● Синхронная загрузка результата из Task<T> блокирует вызывающий
поток до завершения задачи; ValueTask<T> таких гарантий не дает.
● Синхронное получение результатов от ValueTask или ValueTask<T>
● может быть выполнено только один раз, после завершения ValueTask.
.NET Meetup

IAsyncEnumerable<T>
Работает так же, как и IEnumerable<T>, только асинхронно получает каждый
следующий элемент.
.NET Meetup

IAsyncEnumerable<T>
.NET Meetup
async IAsyncEnumerable<int> GetValuesAsync()
{
await Task.Delay(1000); // сложные расчеты или загрузка из сети
yield return 1;
await Task.Delay(1000); // сложные расчеты или загрузка из сети
yield return 2;
}

IAsyncEnumerable<T>
.NET Meetup
IAsyncEnumerable<string> GetValuesAsync(HttpClient client);
async Task ProcessValueAsync(HttpClient client)
{
await foreach (string value in GetValuesAsync(client))
{
Console.WriteLine(value);
}
}

IAsyncEnumerable<T>
.NET Meetup
{
await foreach (string value in GetValuesAsync(client))
{
await Task.Delay(100); // асинхронно обрабатываем элемент
}
}

IAsyncEnumerable<T>
.NET Meetup
{
await foreach (string value in GetValuesAsync(client).ConfigureAwait(false)))
{
await Task.Delay(100).ConfigureAwait(false)); // асинхронно обрабатываем элемент
}
}

.NET Meetup
async IAsyncEnumerable<string> GetValuesAsync(HttpClient client)
{
int offset = 0;
const int limit = 10;
while (true)
{
var result = await client.GetStringAsync($"https://my.com/api/values?offset={offset}&limit={limit}");
string[] items = result.Split('n');
foreach (string item in items)
yield return item;
if (items.Length < limit)
break; // елементов меньше - последняя страница
offset += limit;
}
}

Ожидание нескольких задач
.NET Meetup

.NET Meetup
Task task1 = Task.Delay(TimeSpan.FromSeconds(3));
await Task.WhenAll(task1, task2, task3);

.NET Meetup
Task<int> task1 = Task.FromResult(3);
int[] results = await Task.WhenAll(task1, task2, task3);

.NET Meetup
async Task ProcessTasksAsync()
{
Task<string> taskA = DelayAndReturnAsync(3, "medium");
Task<string> taskB = DelayAndReturnAsync(5, "slow");
Task<string> taskC = DelayAndReturnAsync(1, "fast");
Task<string>[] tasks = new[] { taskA, taskB, taskC };
foreach (var task in tasks)
{
var result = await task;
Results.Add(result);
}
}
async Task<string> DelayAndReturnAsync(int delay, string value)
{
await Task.Delay(TimeSpan.FromSeconds(delay));
return value;
}

.NET Meetup
{
foreach (var task in tasks)
{
var result = await task;
Results.Add(result);
}
}
async Task<string> DelayAndReturnAsync(int delay, string value)
{
await Task.Delay(TimeSpan.FromSeconds(delay));
return value;
}
"medium"
"slow"
"fast"

.NET Meetup
{
Task<string>[] processingTasks = tasks.Select(async t =>
{
var result = await t;
Result.Add(result);
return result;
}).ToArray();
await Task.WhenAll(processingTasks);
}
"fast"
"medium"
"slow"

Синхронизация
.NET Meetup

Если в вашем приложении используется конкурентность,
следует остерегаться ситуаций, в которых один блок
кода должен обновлять данные, пока другой код
обращается к тем же данным. Столкнувшись с подобной
ситуацией, необходимо синхронизировать доступ к
данным
.NET Meetup

Основные виды синхронизации:
● передачи данных
● защиты данных
.NET Meetup

Синхронизация для защиты
Необходима при выполнении всех трех условий:
1. Несколько частей кода выполняются одновременно
2. Общие данные
3. Обновление данных
.NET Meetup

Синхронизация для защиты
Цель защиты данных заключается в том, чтобы каждая
часть кода имела целостное представление данных.
Если одна часть кода обновляет данные, вы можете
воспользоваться синхронизацией, чтобы обновления
воспринимались как атомарные для остальных
компонентов системы.
.NET Meetup

Нужна синхронизации для value?
.NET Meetup
async Task<int> MyMethodAsync()
{
int value = 10;
value += 1;
value += 1;
return await Task.FromResult(value);
}

.NET Meetup
async Task<int> MyMethodAsync()
{
int value = 10;
value += 1;
value += 1;
return await Task.FromResult(value);
}
Нет

.NET Meetup
private int value;
async Task ModifyValueAsync()
{
var originalValue = value;
value = originalValue + 1;
}

.NET Meetup
private int value;
async Task ModifyValueAsync()
{
var originalValue = value;
value = originalValue + 1;
}
Да

Lock блокировка
.NET Meetup
private readonly object _mutex = new object();
private int _value;
public void Increment()
{
lock (_mutex)
{
_value = _value + 1;
}
}

Lock блокировка
.NET Meetup
● Ограничьте видимость блокировки:
private объект, не string, не this
● Защищать только то, что должно быть защищено
● Минимальный объем кода, защищенного блокировкой:
минимум блокирующих вызовов в lock
● Никакого произвольного кода при удержании блокировки:
не инициируйте события, не вызывайте делегаты и другие методы

Async блокировка
.NET Meetup

.NET Meetup
private readonly SemaphoreSlim _mutex = new SemaphoreSlim(1);
private int _value;
public async Task DelayAndIncrementAsync()
{
await _mutex.WaitAsync();
try
{
int oldValue = _value;
await Task.Delay(TimeSpan.FromSeconds(oldValue));
_value = oldValue + 1;
}
finally
{
_mutex.Release();
}
}

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

Блокировка через сигналы
.NET Meetup
private readonly ManualResetEventSlim _initialized = new ManualResetEventSlim();
private int _value;
public int ReturnResultFromThreadA()
{
_initialized.Wait();
return _value;
}
public void InitializeFromThreadB()
{
_value = 13;
_initialized.Set();
}

Async блокировка через сигналы
.NET Meetup
private readonly TaskCompletionSource<object> _initialized = new TaskCompletionSource<object>();
private int _value;
public async Task<int> WaitForInitializationAsync()
{
await _initialized.Task;
return _value1 + 1;
}
public void Initialize()
{
_value = 5;
_initialized.TrySetResult(null);
}

Исключения
.NET Meetup

Исключения
.NET Meetup
async Task TestAsync()
{
try
{
await ThrowExceptionAsync();
}
catch (InvalidOperationException)
{
}
}
async Task ThrowExceptionAsync()
{
await
Task.Delay(TimeSpan.FromSeconds(5));
throw new InvalidOperationException("Error");
}

.NET Meetup
async Task ObserveOneExceptionAsync()
{
var task1 = ThrowNotImplementedExceptionAsync();
var task2 = ThrowInvalidOperationExceptionAsync();
try
{
await Task.WhenAll(task1, task2);
}
{
// Какие exception будут здесь?
}
}
async Task ThrowNotImplementedExceptionAsync()
{
throw new NotImplementedException();
}
async Task ThrowInvalidOperationExceptionAsync()
{
throw new InvalidOperationException();
}

.NET Meetup
async Task ObserveOneExceptionAsync()
{
var task1 = ThrowNotImplementedExceptionAsync();
var task2 = ThrowInvalidOperationExceptionAsync();
Task allTasks = Task.WhenAll(task1, task2);
try
{
await allTasks;
}
{
AggregateException allExceptions =
allTasks.Exception;
}
}
async Task ThrowNotImplementedExceptionAsync()
{
throw new NotImplementedException();
}
async Task ThrowInvalidOperationExceptionAsync()
{
throw new InvalidOperationException();
}

async Task<MultipartFormDataStreamProvider> Read(HttpContent content)
{
var multipartContentProvider = new MultipartFormDataStreamProvider(_tmpFolderPath);
var task = content.ReadAsMultipartAsync(multipartContentProvider);
if (task.IsFaulted || task.IsCanceled)
throw new ContentFormatException($"HTTP message is not in correct format");
return await task;
}
Исключения: Bad Code
.NET Meetup

.NET Meetup
async Task TestAsync()
{
Task task = ThrowExceptionAsync(); // Исключение выдается методом и помещается в задачу
try
{
await task; // Здесь исключение будет выдано повторно
}
catch (Exception)
{
// Здесь исключение правильно перехватывается.
}
}
Исключения: Good Code

Задержка
Когда может понадобиться:
● В надежде, что другая операция закончилась
● Тестирование
● Повтор операции через время
.NET Meetup

.NET Meetup
Задержка
async Task<T> DelayResult<T>(T result, TimeSpan delay)
{
Thread.Sleep(delay);
return await Task.FromResult(result);
}

.NET Meetup
Задержка
{
Thread.Sleep(delay);
return await Task.FromResult(result);
}
{
await Task.Delay(delay);
return result;
}

Задержка
Повтор операции
● Без задержки
● С постоянной задержкой
● С увеличивающейся задержкой
.NET Meetup

.NET Meetup
async Task<string> DownloadStringWithRetries(HttpClient client, string uri)
{
for (int i = 0; i < 4; i++)
{
try
{
}
catch
{
}
}
}

.NET Meetup
{
TimeSpan delay = TimeSpan.FromSeconds(2);
for (int i = 0; i < 4; i++)
{
try
{
}
catch
{
}
}
}

.NET Meetup
{
TimeSpan delay = TimeSpan.FromSeconds(1);
for (int i = 0; i < 4; i++)
{
try
{
}
catch
{
}
delay = delay + delay;
}
}

Отмена
● По таймеру
● Из вызывающего потока
● Игнорировать результат выполнения потока
.NET Meetup

Отмена
.NET Meetup
void IssueCancelRequest()
{
using var cts = new CancellationTokenSource();
var task = CancelableMethodAsync(cts.Token);
...
cts.Cancel();
}

.NET Meetup
async Task IssueCancelRequestAsync()
{
var task = CancelableMethodAsync(cts.Token);
...
cts.Cancel();
try
{
await task; // операция выполнилась успешно до запроса на завершение
}
catch (OperationCanceledException)
{
// операция была отменена
}
catch (Exception)
{
// операция завершилась с другой ошибкой до отмены
}
}

Ожидание отмены
.NET Meetup
public void CancelableMethod(CancellationToken cancellationToken)
{
for (int i = 0; i < 100000; i++)
{
// some work here
Thread.Sleep(1);
if (i % 1000 == 0)
cancellationToken.ThrowIfCancellationRequested();
}
}

Отмена по таймауту
● Конкурентный поток с фиксированным временем
выполнения
● CancellationToken
.NET Meetup

Таймаут конкурентным потоком
.NET Meetup
async Task<string> DownloadStringWithTimeout(HttpClient client, string uri)
{
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
Task<string> downloadTask = client.GetStringAsync(uri);
Task timeoutTask = Task.Delay(Timeout.InfiniteTimeSpan, cts.Token);
Task completedTask = await Task.WhenAny(downloadTask, timeoutTask);
if (completedTask == timeoutTask)
return null;
return await downloadTask;
}

CancellationToken таймаут
.NET Meetup
async Task IssueTimeoutAsync()
{
CancellationToken token = cts.Token;
cts.CancelAfter(TimeSpan.FromSeconds(5));
await Task.Delay(TimeSpan.FromSeconds(10), token);
}

Комбинирование отмены
.NET Meetup
async Task<HttpResponseMessage> GetWithTimeoutAsync(HttpClient client,
string url, CancellationToken cancellationToken)
{
using CancellationTokenSource cts = CancellationTokenSource
.CreateLinkedTokenSource(cancellationToken);
cts.CancelAfter(TimeSpan.FromSeconds(2));
CancellationToken combinedToken = cts.Token;
return await client.GetAsync(url, combinedToken);
}

Прогресс
Используем IProgress<T> и Progress<T>.
Async-метод получает аргумент IProgress<T>;
T - тип прогресса, о котором хотим сообщать.
.NET Meetup

.NET Meetup
async Task CallMyMethodAsync()
{
var progress = new Progress<double>();
progress.ProgressChanged += (sender, args) =>
{
...
};
await MyMethodAsync(progress);
}
async Task MyMethodAsync(IProgress<double> progress = null)
{
bool done = false;
double percentComplete = 0;
while (!done)
{
...
progress?.Report(percentComplete);
}
}

Вопрос к аудитории
.NET Meetup

Вопрос к аудитории
Сколько потоков ждут ответа от устройства?
.NET Meetup
private async void Button_Click(object sender, RoutedEventArgs e)
{
byte[] data = ...
await someDevice.WriteAsync(data, 0, data.Length);
}

There is no thread
.NET Meetup

Thank you
For your attention!
Any Questions?
.NET Meetup

Wild Async .NET world: AID Kit for boy-scouts

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Wild Async .NET world: AID Kit for boy-scouts

Similar to Wild Async .NET world: AID Kit for boy-scouts (20)

More from HYS Enterprise

More from HYS Enterprise (20)

Wild Async .NET world: AID Kit for boy-scouts