CPU-bound и I/O-bound асинхронные и синхронные операции на C#

// Плохо - false sharing
class Statistics 
{
    public long[] Counters = new long[Environment.ProcessorCount];
}
 
// Лучше - каждый счетчик на отдельной строке кеша
[StructLayout(LayoutKind.Explicit, Size = 64)]
struct PaddedCounter 
{
    [FieldOffset(0)]
    public long Value;
}
 
class Statistics 
{
    public PaddedCounter[] Counters = new PaddedCounter[Environment.ProcessorCount];
}

// Обычный цикл
for (int i = 0; i < array.Length; i++)
{
    array[i] = array[i] * 2 + 10;
}
 
// С использованием Vector<T> - обрабатывает Vector<float>.Count элементов за раз
int vectorSize = Vector<float>.Count;
for (int i = 0; i <= array.Length - vectorSize; i += vectorSize)
{
    var vector = new Vector<float>(array, i);
    vector = vector * new Vector<float>(2f) + new Vector<float>(10f);
    vector.CopyTo(array, i);
}
// Остаток обрабатываем обычным циклом

public int[] SortArray(int[] data)
{
    // Синхронная сортировка - быстро, просто, эффективно
    Array.Sort(data);
    return data;
}
 
// Асинхронная версия бессмысленна
public async Task<int[]> SortArrayAsync(int[] data)
{
    // Это просто запуск в другом потоке, не настоящая асинхронность
    return await Task.Run(() => 
    {
        Array.Sort(data);
        return data;
    });
}

public byte[] ComputeHash(byte[] data)
{
    using var sha = SHA256.Create();
    return sha.ComputeHash(data); // CPU жарит на полную
}

public byte[] CompressData(byte[] input)
{
    using var output = new MemoryStream();
    using (var compressor = new BrotliStream(output, CompressionLevel.Optimal))
    {
        compressor.Write(input, 0, input.Length);
    }
    return output.ToArray();
}

public byte[] EncryptData(byte[] plaintext, byte[] key, byte[] iv)
{
    using var aes = Aes.Create();
    aes.Key = key;
    aes.IV = iv;
    
    using var encryptor = aes.CreateEncryptor();
    using var ms = new MemoryStream();
    using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
    {
        cs.Write(plaintext, 0, plaintext.Length);
    }
    return ms.ToArray();
}

public LogStatistics ProcessLog(string[] lines)
{
    var stats = new LogStatistics();
    
    // Последовательная обработка - просто и быстро
    foreach (var line in lines)
    {
        if (line.Contains("ERROR"))
            stats.ErrorCount++;
        else if (line.Contains("WARNING"))
            stats.WarningCount++;
        
        stats.TotalLines++;
    }
    
    return stats;
}

public OrderSummary CalculateOrderSummary(List<OrderItem> items)
{
    // Чистые вычисления в памяти
    var summary = new OrderSummary
    {
        TotalItems = items.Count,
        TotalAmount = items.Sum(x => x.Price * x.Quantity),
        AveragePrice = items.Average(x => x.Price),
        Categories = items.Select(x => x.Category).Distinct().ToList()
    };
    
    // Применяем скидку если больше 5 товаров
    if (summary.TotalItems > 5)
        summary.TotalAmount *= 0.95m;
    
    return summary;
}

// Обработка большого набора данных
var largeDataset = Enumerable.Range(0, 10_000_000).ToArray();
 
// PLINQ для CPU-bound параллелизма - правильный подход
var result = largeDataset
    .AsParallel()
    .Where(x => IsPrime(x))
    .ToList();
 
// Async/await тут не нужен - это чистые вычисления

public Report GenerateReport(ReportData data)
{
    var report = new Report();
    
    // Формируем заголовок - синхронно, быстро
    report.Header = FormatHeader(data.Title, DateTime.Now);
    
    // Агрегируем строки - вычисления в памяти
    report.Rows = data.Items
        .GroupBy(x => x.Category)
        .Select(g => new ReportRow
        {
            Category = g.Key,
            Count = g.Count(),
            Total = g.Sum(x => x.Amount)
        })
        .OrderByDescending(x => x.Total)
        .ToList();
    
    // Добавляем итоги
    report.Summary = CalculateSummary(report.Rows);
    
    return report;
}
 
public async Task SaveReportAsync(Report report, string path)
{
    // А вот тут async оправдан - пишем в файл
    var json = JsonSerializer.Serialize(report);
    await File.WriteAllTextAsync(path, json);
}

// Бессмысленный async
public async Task<int> GetConfigValueAsync(string key)
{
    return await Task.FromResult(_config[key]);
}
 
// Просто верните значение
public int GetConfigValue(string key)
{
    return _config[key];
}

public async Task<string> ReadConfigFileAsync(string path)
{
    // Поток не блокируется на чтении
    string content = await File.ReadAllTextAsync(path);
    
    // Продолжение выполнится когда данные будут готовы
    return content.Trim();
}

public async Task<WeatherData> GetWeatherAsync(string city)
{
    using var client = new HttpClient();
    
    // Отправили запрос - поток освобожден
    var response = await client.GetStringAsync($"https://api.weather.com/v1/city/{city}");
    
    // Десериализация уже на continuation, когда данные пришли
    return JsonSerializer.Deserialize<WeatherData>(response);
}

// Синхронная блокировка - поток занят
public void ProcessWithDelay()
{
    Thread.Sleep(5000); // Поток спит, но занят
    DoWork();
}
 
// Асинхронное ожидание - поток свободен
public async Task ProcessWithDelayAsync()
{
    await Task.Delay(5000); // Поток вернулся в пул
    DoWork(); // Выполнится на любом свободном потоке через 5 секунд
}

public async Task<List<User>> GetActiveUsersAsync()
{
    await using var context = new AppDbContext();
    
    // Запрос уходит в БД, поток освобождается
    return await context.Users
        .Where(u => u.IsActive)
        .ToListAsync();
}

public async Task<string> FetchDataWithRetryAsync(string url)
{
    using var client = new HttpClient();
    int attempts = 0;
    
    while (attempts < 3)
    {
        try
        {
            // Асинхронный запрос - не держим поток
            var result = await client.GetStringAsync(url);
            return result;
        }
        catch (HttpRequestException)
        {
            attempts++;
            if (attempts >= 3) throw;
            
            // Асинхронная пауза перед повтором
            await Task.Delay(1000 * attempts);
        }
    }
    
    throw new Exception("Failed after retries");
}

public async Task ProcessDataAsync()
{
    Console.WriteLine($"Before await: Thread {Thread.CurrentThread.ManagedThreadId}");
    
    await Task.Delay(1000);
    
    // Continuation может выполниться на другом потоке
    Console.WriteLine($"After await: Thread {Thread.CurrentThread.ManagedThreadId}");
}

public async Task<IActionResult> GetDataAsync()
{
    // Контроллер ASP.NET Core, контекст не захватывается
    var data = await _repository.GetDataAsync();
    
    // Continuation выполнится на любом потоке пула
    return Ok(data);
}

public async Task<string> LoadConfigAsync()
{
    // В библиотечном коде часто используют ConfigureAwait(false)
    var content = await File.ReadAllTextAsync("config.json")
        .ConfigureAwait(false);
    
    // Продолжение на любом потоке, без захвата контекста
    return content;
}

public async Task<IEnumerable<Product>> GetProductsAsync(int categoryId)
{
    using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync(); // Асинхронное открытие соединения
    
    // Асинхронное выполнение запроса
    return await connection.QueryAsync<Product>(
        "SELECT * FROM Products WHERE CategoryId = @CategoryId",
        new { CategoryId = categoryId }
    );
}

public async Task<DashboardData> LoadDashboardAsync(int userId)
{
    // Запускаем все запросы параллельно
    var userTask = _userRepository.GetUserAsync(userId);
    var ordersTask = _orderRepository.GetRecentOrdersAsync(userId);
    var statsTask = _analyticsRepository.GetUserStatsAsync(userId);
    
    // Ждём завершения всех
    await Task.WhenAll(userTask, ordersTask, statsTask);
    
    // Результаты уже готовы, никакого дополнительного ожидания
    return new DashboardData 
    {
        User = userTask.Result,
        Orders = ordersTask.Result,
        Stats = statsTask.Result
    };
}

public async IAsyncEnumerable<LogEntry> ReadLargeLogFileAsync(string path)
{
    await using var stream = File.OpenRead(path);
    using var reader = new StreamReader(stream);
    
    string line;
    while ((line = await reader.ReadLineAsync()) != null)
    {
        if (TryParseLine(line, out var entry))
            yield return entry;
    }
}
 
// Использование
await foreach (var entry in ReadLargeLogFileAsync("huge.log"))
{
    ProcessEntry(entry); // Обрабатываем по одной записи
    // Память не раздувается, поток не блокируется
}

public async Task ProcessOrderAsync(int orderId)
{
    // Читаем настройки - I/O
    var config = await LoadConfigAsync();
    
    // Получаем заказ из БД - I/O
    var order = await _db.Orders.FindAsync(orderId);
    
    // Запрашиваем статус доставки у внешнего API - I/O
    var delivery = await _deliveryClient.GetStatusAsync(order.TrackingNumber);
    
    // Обновляем в БД - I/O
    order.DeliveryStatus = delivery.Status;
    await _db.SaveChangesAsync();
    
    // Отправляем уведомление - I/O
    await _notificationService.SendAsync(order.CustomerId, 
        $"Ваш заказ: {delivery.Status}");
}

private readonly ConcurrentDictionary<int, SemaphoreSlim> _locks = new();
 
public async Task<User> GetUserWithCacheAsync(int userId)
{
    // Быстрая проверка кеша - синхронно
    if (_cache.TryGetValue(userId, out User cached))
        return cached;
    
    // Защита от множественной загрузки одних данных
    var semaphore = _locks.GetOrAdd(userId, _ => new SemaphoreSlim(1, 1));
    await semaphore.WaitAsync();
    
    try
    {
        // Повторная проверка - могли загрузить пока ждали
        if (_cache.TryGetValue(userId, out cached))
            return cached;
        
        // Асинхронная загрузка из БД
        var user = await _db.Users.FindAsync(userId);
        _cache[userId] = user;
        return user;
    }
    finally
    {
        semaphore.Release();
    }
}

public async Task<string> FetchWithTimeoutAsync(string url, int timeoutMs)
{
    using var cts = new CancellationTokenSource(timeoutMs);
    using var client = new HttpClient();
    
    try
    {
        return await client.GetStringAsync(url, cts.Token);
    }
    catch (OperationCanceledException)
    {
        throw new TimeoutException($"Request timed out after {timeoutMs}ms");
    }
}

// Наивный подход - просто обернули в Task.Run
public async Task<byte[]> CompressDataAsync(byte[] input)
{
    return await Task.Run(() =>
    {
        // Процессор жарит так же, просто в другом потоке
        using var output = new MemoryStream();
        using (var compressor = new GZipStream(output, CompressionLevel.Optimal))
        {
            compressor.Write(input, 0, input.Length);
        }
        return output.ToArray();
    });
}

// Катастрофически плохо
public async Task ProcessManyItemsAsync(int[] items)
{
    var tasks = new List<Task>();
    
    foreach (var item in items)
    {
        // Создаём 10000 задач!
        tasks.Add(Task.Run(() => ProcessItem(item)));
    }
    
    await Task.WhenAll(tasks);
}
 
// Правильный подход - контролируем параллелизм
public void ProcessManyItems(int[] items)
{
    Parallel.ForEach(items, new ParallelOptions 
    { 
        MaxDegreeOfParallelism = Environment.ProcessorCount 
    }, 
    item => ProcessItem(item));
}

// Библиотечный метод без ConfigureAwait - опасно
public async Task<string> LoadDataAsync()
{
    var bytes = await File.ReadAllBytesAsync("data.bin");
    // Continuation попытается вернуться в исходный контекст
    return Convert.ToBase64String(bytes);
}
 
// Правильно - не захватываем контекст
public async Task<string> LoadDataAsync()
{
    var bytes = await File.ReadAllBytesAsync("data.bin")
        .ConfigureAwait(false);
    // Продолжение на любом потоке пула
    return Convert.ToBase64String(bytes);
}

// Плохая практика в библиотеке
public async Task<int> CalculateSomethingAsync(int[] data)
{
    // Неявно создаёте поток - плохо
    return await Task.Run(() => 
    {
        int result = 0;
        for (int i = 0; i < data.Length; i++)
            result += data[i] * data[i];
        return result;
    });
}
 
// Правильно - синхронный метод для CPU-bound
public int CalculateSomething(int[] data)
{
    int result = 0;
    for (int i = 0; i < data.Length; i++)
        result += data[i] * data[i];
    return result;
}
 
// Пусть вызывающий решает про потоки
var result = await Task.Run(() => library.CalculateSomething(data));

// Кеш с ValueTask - меньше аллокаций
public ValueTask<User> GetUserAsync(int id)
{
    // Если в кеше - возвращаем синхронно без аллокации
    if (_cache.TryGetValue(id, out var user))
        return new ValueTask<User>(user);
    
    // Иначе асинхронно загружаем
    return new ValueTask<User>(LoadUserFromDbAsync(id));
}
 
private async Task<User> LoadUserFromDbAsync(int id)
{
    var user = await _db.Users.FindAsync(id);
    _cache[id] = user;
    return user;
}

// Мелкая операция - async не нужен
public async Task<int> GetCachedValueAsync(string key)
{
    // Обращение к ConcurrentDictionary быстрое
    if (_cache.TryGetValue(key, out int value))
        return value;
    
    return 0;
}
 
// Лучше синхронно
public int GetCachedValue(string key)
{
    return _cache.TryGetValue(key, out int value) ? value : 0;
}

// Опасно - исключение убьёт приложение
public async void ProcessDataAsync()
{
    await Task.Delay(100);
    throw new Exception("Boom!"); // Unhandled exception!
}
 
// Правильно - возвращайте Task
public async Task ProcessDataAsync()
{
    await Task.Delay(100);
    throw new Exception("Boom!"); // Можно поймать через try-catch у вызывающего
}

// Классический дедлок в UI-приложении
private void Button_Click(object sender, EventArgs e)
{
    // UI-поток вызывает async метод и ждёт синхронно
    var result = LoadDataAsync().Result; // Застряли!
}
 
private async Task<string> LoadDataAsync()
{
    await Task.Delay(1000); 
    // Пытается вернуться в UI-поток, который заблокирован выше
    return "Done";
}

// Неэффективно - запускаем слишком много параллельных CPU-bound задач
public async Task<int[]> ProcessManyNumbersAsync(int[] numbers)
{
    var tasks = numbers.Select(n => Task.Run(() => HeavyComputation(n)));
    return await Task.WhenAll(tasks);
}
 
// Правильно - ограничиваем параллелизм
public int[] ProcessManyNumbers(int[] numbers)
{
    var result = new int[numbers.Length];
    Parallel.For(0, numbers.Length, new ParallelOptions
    {
        MaxDegreeOfParallelism = Environment.ProcessorCount
    },
    i => result[i] = HeavyComputation(numbers[i]));
    
    return result;
}

// Катастрофа - вложенный параллелизм
public async Task ProcessBatchesAsync(List<Batch> batches)
{
    var tasks = batches.Select(batch => Task.Run(async () =>
    {
        // Внутри еще параллелизм!
        var itemTasks = batch.Items.Select(item => 
            Task.Run(() => ProcessItem(item)));
        await Task.WhenAll(itemTasks);
    }));
    
    await Task.WhenAll(tasks);
}

// Иллюзия производительности
public async Task<List<Result>> ProcessInParallelAsync(List<Data> items)
{
    // 16 задач на 4 ядрах - половина времени потоки простаивают в очереди
    var tasks = items.Select(item => Task.Run(() => CpuIntensiveWork(item)));
    return (await Task.WhenAll(tasks)).ToList();
}

// Неправильно - Task.Run на каждый клик
private async void CalculateButton_Click(object sender, EventArgs e)
{
    var result = await Task.Run(() => 
    {
        // Тяжёлые вычисления
        Thread.Sleep(5000);
        return 42;
    });
    
    ResultLabel.Text = result.ToString();
}

private CancellationTokenSource _cts;
 
private async void CalculateButton_Click(object sender, EventArgs e)
{
    // Отменяем предыдущую операцию если есть
    _cts?.Cancel();
    _cts = new CancellationTokenSource();
    
    CalculateButton.Enabled = false;
    try
    {
        var result = await Task.Run(() => 
            HeavyCalculation(_cts.Token), _cts.Token);
        ResultLabel.Text = result.ToString();
    }
    catch (OperationCanceledException)
    {
        ResultLabel.Text = "Отменено";
    }
    finally
    {
        CalculateButton.Enabled = true;
    }
}

// Исключение проглатывается!
public void StartBackgroundWork()
{
    // Task запущен, но никто не ждёт результат
    Task.Run(() => 
    {
        throw new Exception("Проблема!"); // Никто не увидит это исключение
    });
    
    // Метод завершается нормально, Task летит в неизвестность
}
 
// Правильный подход - сохраняем Task и обрабатываем
private Task _backgroundTask;
 
public void StartBackgroundWork()
{
    _backgroundTask = Task.Run(() => 
    {
        try 
        {
            // Работа
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка в фоновой задаче");
            throw; // Пробрасываем для последующей проверки
        }
    });
}
 
// Где-то проверяем результат
public async Task CheckBackgroundWorkAsync()
{
    if (_backgroundTask != null)
    {
        try 
        {
            await _backgroundTask;
        }
        catch (Exception ex)
        {
            // Теперь exception обработан
        }
    }
}

public class DataProcessor
{
    private readonly EventAggregator _events;
    
    public DataProcessor(EventAggregator events)
    {
        _events = events;
        // Подписываемся на событие с async обработчиком
        _events.Subscribe<DataEvent>(async e => await ProcessAsync(e));
    }
    
    private async Task ProcessAsync(DataEvent e)
    {
        await Task.Delay(100); // Имитация работы
        // Обработка
    }
    
    // Забыли отписаться - утечка памяти!
    // DataProcessor не будет собран GC, пока жив EventAggregator
}

public async Task<int> LongComputationAsync(int[] data, CancellationToken ct)
{
    return await Task.Run(() =>
    {
        int result = 0;
        
        for (int i = 0; i < data.Length; i++)
        {
            // Периодически проверяем отмену
            if (i % 1000 == 0)
                ct.ThrowIfCancellationRequested();
            
            // Тяжёлые вычисления
            result += ComplexCalculation(data[i]);
        }
        
        return result;
    }, ct);
}

// Генерирует огромное количество мусора
public async Task ProcessStreamAsync(Stream stream)
{
    var buffer = new byte[1024];
    int bytesRead;
    
    while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
    {
        // На каждой итерации - новый Task, новый state machine
        await ProcessChunkAsync(buffer, bytesRead);
    }
}
 
// Лучше - минимизируем async границы
public async Task ProcessStreamAsync(Stream stream)
{
    var buffer = new byte[1024];
    int bytesRead;
    
    while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
    {
        // Синхронная обработка - никаких лишних аллокаций
        ProcessChunk(buffer, bytesRead);
    }
}

public async Task<string> GetUserDataAsync(int userId)
{
    var user = await _repository.GetUserAsync(userId);
    var profile = await _profileService.GetProfileAsync(user.ProfileId);
    var settings = await _settingsService.GetSettingsAsync(user.Id);
    
    // Если тут exception, stack trace покажет:
    // - Три разных state machine
    // - Разные потоки выполнения
    // - Непонятную последовательность
    
    return BuildUserData(user, profile, settings);
}

// Выглядит невинно
public async Task<Result> ProcessRequestAsync(Request request)
{
    var data = await LoadDataAsync(request.Id);
    var validated = await ValidateAsync(data);
    var processed = await ProcessAsync(validated);
    var saved = await SaveAsync(processed);
    return new Result(saved);
}
 
// Но каждый await - это:
// - Проверка состояния Task
// - Возможное переключение потока
// - Захват контекста
// - Аллокация continuation
// - Постановка в очередь планировщика

// Антипаттерн - async для быстрой операции
public async Task<int> GetCachedCountAsync()
{
    return await Task.FromResult(_cache.Count);
}
 
// Просто верните значение
public int GetCachedCount()
{
    return _cache.Count;
}

var sw = Stopwatch.StartNew();
 
// Синхронная версия
for (int i = 0; i < 1000; i++)
{
    ProcessItem(items[i]);
}
 
sw.Stop();
Console.WriteLine($"Sync: {sw.ElapsedMilliseconds}ms");
 
sw.Restart();
 
// Асинхронная версия
var tasks = items.Select(item => ProcessItemAsync(item));
await Task.WhenAll(tasks);
 
sw.Stop();
Console.WriteLine($"Async: {sw.ElapsedMilliseconds}ms");

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
 
[MemoryDiagnoser]
[ThreadingDiagnoser]
public class AsyncVsSyncBenchmark
{
    private readonly byte[] _data = new byte[1024 * 1024]; // 1 МБ
 
    [GlobalSetup]
    public void Setup()
    {
        new Random(42).NextBytes(_data);
    }
 
    [Benchmark(Baseline = true)]
    public byte[] SyncCompress()
    {
        using var output = new MemoryStream();
        using (var compressor = new GZipStream(output, CompressionLevel.Fastest))
        {
            compressor.Write(_data, 0, _data.Length);
        }
        return output.ToArray();
    }
 
    [Benchmark]
    public async Task<byte[]> AsyncCompress()
    {
        using var output = new MemoryStream();
        using (var compressor = new GZipStream(output, CompressionLevel.Fastest))
        {
            await compressor.WriteAsync(_data, 0, _data.Length);
        }
        return output.ToArray();
    }
 
    [Benchmark]
    public async Task<byte[]> TaskRunCompress()
    {
        return await Task.Run(() => SyncCompress());
    }
}
 
// Запуск
class Program
{
    static void Main() => BenchmarkRunner.Run<AsyncVsSyncBenchmark>();
}

|          Method |     Mean |    Error |   StdDev | Ratio | Gen 0 | Gen 1 | Allocated |
|---------------- |---------:|---------:|---------:|------:|------:|------:|----------:|
|    SyncCompress | 12.43 ms | 0.121 ms | 0.113 ms |  1.00 |  31.2 |   -   |   262 KB  |
|   AsyncCompress | 12.89 ms | 0.187 ms | 0.175 ms |  1.04 |  31.2 |   -   |   264 KB  |
| TaskRunCompress | 13.52 ms | 0.203 ms | 0.190 ms |  1.09 |  31.2 | 15.6  |   266 KB  |

[MemoryDiagnoser]
public class FileReadBenchmark
{
    private readonly string _filePath = "test_10mb.bin";
 
    [GlobalSetup]
    public void Setup()
    {
        // Создаем тестовый файл 10 МБ
        File.WriteAllBytes(_filePath, new byte[10 * 1024 * 1024]);
    }
 
    [Benchmark(Baseline = true)]
    public byte[] SyncRead()
    {
        return File.ReadAllBytes(_filePath);
    }
 
    [Benchmark]
    public async Task<byte[]> AsyncRead()
    {
        return await File.ReadAllBytesAsync(_filePath);
    }
 
    [GlobalCleanup]
    public void Cleanup()
    {
        File.Delete(_filePath);
    }
}

|    Method |     Mean |   Error |  StdDev | Ratio | Allocated |
|---------- |---------:|--------:|--------:|------:|----------:|
| SyncRead  | 18.23 ms | 0.34 ms | 0.32 ms |  1.00 |  10.01 MB |
| AsyncRead | 17.89 ms | 0.28 ms | 0.26 ms |  0.98 |  10.01 MB |

[MemoryDiagnoser]
[ThreadingDiagnoser]
public class ParallelProcessingBenchmark
{
    private int[] _data;
 
    [Params(1000, 10000, 100000)]
    public int DataSize { get; set; }
 
    [GlobalSetup]
    public void Setup()
    {
        _data = Enumerable.Range(0, DataSize).ToArray();
    }
 
    [Benchmark]
    public void SequentialProcessing()
    {
        for (int i = 0; i < _data.Length; i++)
        {
            _data[i] = ComputeValue(_data[i]);
        }
    }
 
    [Benchmark]
    public void ParallelForEach()
    {
        Parallel.ForEach(_data, (value, state, index) =>
        {
            _data[index] = ComputeValue(value);
        });
    }
 
    [Benchmark]
    public async Task TaskWhenAll()
    {
        var tasks = _data.Select(async (value, index) =>
        {
            await Task.Yield(); // Имитация async операции
            _data[index] = ComputeValue(value);
        });
        await Task.WhenAll(tasks);
    }
 
    private int ComputeValue(int x)
    {
        // Имитация CPU-bound работы
        int result = x;
        for (int i = 0; i < 100; i++)
            result = (result * 31 + x) % 1000000;
        return result;
    }
}

// Проблемный код - closure на каждой итерации
public async Task ProcessItemsAsync(List<Item> items)
{
    var tasks = new List<Task>();
    
    foreach (var item in items)
    {
        // Closure захватывает item - аллокация на каждой итерации
        tasks.Add(Task.Run(async () =>
        {
            await ProcessAsync(item);
        }));
    }
    
    await Task.WhenAll(tasks);
}
 
// Оптимизированная версия
public async Task ProcessItemsAsync(List<Item> items)
{
    var tasks = new Task[items.Count];
    
    for (int i = 0; i < items.Count; i++)
    {
        var item = items[i]; // Локальная копия для избежания closure
        tasks[i] = ProcessAsync(item); // Прямой вызов без Task.Run
    }
    
    await Task.WhenAll(tasks);
}

// Много аллокаций на горячем пути
public async Task<string> FormatDataAsync(Data data)
{
    var sb = new StringBuilder(); // Аллокация
    
    foreach (var item in data.Items)
    {
        // Closure - аллокация
        await Task.Run(() => 
        {
            sb.Append(item.ToString()); // Boxing если item - struct
        });
    }
    
    return sb.ToString(); // Еще одна аллокация строки
}
 
// Оптимизированная версия
public string FormatData(Data data)
{
    // StringBuilder переиспользуется или pooled
    var sb = _stringBuilderPool.Get();
    
    try
    {
        foreach (var item in data.Items)
        {
            // Синхронно, никаких Task и closure
            item.AppendToStringBuilder(sb); // Без boxing
        }
        
        return sb.ToString();
    }
    finally
    {
        _stringBuilderPool.Return(sb);
    }
}

// Измеряем throughput
public async Task MeasureThroughputAsync()
{
    var requests = 10000;
    var sw = Stopwatch.StartNew();
    
    // Синхронный вариант
    for (int i = 0; i < requests; i++)
    {
        ProcessRequest(i);
    }
    sw.Stop();
    Console.WriteLine($"Sync throughput: {requests / sw.Elapsed.TotalSeconds:F0} req/s");
    
    sw.Restart();
    
    // Асинхронный вариант с ограничением параллелизма
    var semaphore = new SemaphoreSlim(100); // максимум 100 одновременных операций
    var tasks = new List<Task>();
    
    for (int i = 0; i < requests; i++)
    {
        await semaphore.WaitAsync();
        var task = ProcessRequestAsync(i).ContinueWith(_ => semaphore.Release());
        tasks.Add(task);
    }
    
    await Task.WhenAll(tasks);
    sw.Stop();
    Console.WriteLine($"Async throughput: {requests / sw.Elapsed.TotalSeconds:F0} req/s");
}

public class LatencyTracker
{
    private readonly List<long> _latencies = new();
    private readonly object _lock = new();
    
    public void RecordLatency(long milliseconds)
    {
        lock (_lock)
        {
            _latencies.Add(milliseconds);
        }
    }
    
    public void PrintStatistics()
    {
        lock (_lock)
        {
            if (_latencies.Count == 0) return;
            
            var sorted = _latencies.OrderBy(x => x).ToArray();
            
            Console.WriteLine($"Min: {sorted.First()}ms");
            Console.WriteLine($"Max: {sorted.Last()}ms");
            Console.WriteLine($"Mean: {sorted.Average():F2}ms");
            Console.WriteLine($"Median (p50): {sorted[sorted.Length / 2]}ms");
            Console.WriteLine($"p95: {sorted[(int)(sorted.Length * 0.95)]}ms");
            Console.WriteLine($"p99: {sorted[(int)(sorted.Length * 0.99)]}ms");
        }
    }
}

// Неправильно - измеряем холодный старт
var sw = Stopwatch.StartNew();
var result = ExpensiveMethod();
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds); // Включает JIT компиляцию!
 
// Правильно - прогреваем перед измерением
for (int i = 0; i < 100; i++)
{
    ExpensiveMethod(); // Warmup: JIT компилирует, кеши прогреваются
}
 
sw.Restart();
for (int i = 0; i < 1000; i++)
{
    ExpensiveMethod();
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds / 1000.0); // Среднее за итерацию

[MemoryDiagnoser]
public class DataSizeBenchmark
{
    private byte[] _smallData = new byte[1024]; // 1 КБ
    private byte[] _mediumData = new byte[1024 * 1024]; // 1 МБ
    private byte[] _largeData = new byte[100 * 1024 * 1024]; // 100 МБ
    
    [Benchmark]
    public int ProcessSmall() => ProcessData(_smallData);
    
    [Benchmark]
    public int ProcessMedium() => ProcessData(_mediumData);
    
    [Benchmark]
    public int ProcessLarge() => ProcessData(_largeData);
    
    private int ProcessData(byte[] data)
    {
        int checksum = 0;
        for (int i = 0; i < data.Length; i++)
        {
            checksum ^= data[i];
        }
        return checksum;
    }
}

// Базовый контракт для всех процессоров
public interface IWorkloadProcessor
{
    string Name { get; }
    Task<ProcessingResult> ProcessAsync(WorkloadData data, CancellationToken ct);
}
 
// Данные для обработки
public class WorkloadData
{
    public byte[] Payload { get; set; }
    public int ComputationIntensity { get; set; } // Коэффициент сложности вычислений
    public int IoOperationsCount { get; set; } // Количество I/O операций
}
 
// Результат обработки с метриками
public class ProcessingResult
{
    public byte[] ProcessedData { get; set; }
    public long ElapsedMilliseconds { get; set; }
    public int ThreadId { get; set; }
    public long MemoryUsedBytes { get; set; }
}

public class SyncCpuBoundProcessor : IWorkloadProcessor
{
    public string Name => "Synchronous CPU-bound";
 
    public Task<ProcessingResult> ProcessAsync(WorkloadData data, CancellationToken ct)
    {
        var sw = Stopwatch.StartNew();
        var startMemory = GC.GetTotalMemory(false);
        
        // Имитируем CPU-intensive работу
        var processed = ProcessDataSync(data.Payload, data.ComputationIntensity, ct);
        
        sw.Stop();
        var endMemory = GC.GetTotalMemory(false);
        
        // Возвращаем уже завершенный Task - никакой реальной асинхронности
        return Task.FromResult(new ProcessingResult
        {
            ProcessedData = processed,
            ElapsedMilliseconds = sw.ElapsedMilliseconds,
            ThreadId = Thread.CurrentThread.ManagedThreadId,
            MemoryUsedBytes = endMemory - startMemory
        });
    }
    
    private byte[] ProcessDataSync(byte[] data, int intensity, CancellationToken ct)
    {
        using var sha = SHA256.Create();
        var result = data;
        
        // Многократное хеширование для увеличения нагрузки
        for (int i = 0; i < intensity; i++)
        {
            // Проверяем отмену каждые 10 итераций
            if (i % 10 == 0)
                ct.ThrowIfCancellationRequested();
                
            result = sha.ComputeHash(result);
        }
        
        // Дополнительно сжимаем результат
        using var output = new MemoryStream();
        using (var compressor = new GZipStream(output, CompressionLevel.Optimal))
        {
            compressor.Write(result, 0, result.Length);
        }
        
        return output.ToArray();
    }
}

public class ParallelCpuBoundProcessor : IWorkloadProcessor
{
    public string Name => "Parallel CPU-bound";
    
    public Task<ProcessingResult> ProcessAsync(WorkloadData data, CancellationToken ct)
    {
        var sw = Stopwatch.StartNew();
        var startMemory = GC.GetTotalMemory(false);
        
        // Разбиваем данные на чанки для параллельной обработки
        var chunkSize = Math.Max(1024, data.Payload.Length / Environment.ProcessorCount);
        var chunks = SplitIntoChunks(data.Payload, chunkSize);
        var results = new byte[chunks.Count][];
        
        // Параллельно обрабатываем каждый чанк
        Parallel.For(0, chunks.Count, new ParallelOptions 
        { 
            MaxDegreeOfParallelism = Environment.ProcessorCount,
            CancellationToken = ct
        }, 
        i =>
        {
            results[i] = ProcessChunk(chunks[i], data.ComputationIntensity);
        });
        
        // Объединяем результаты
        var combined = CombineChunks(results);
        
        sw.Stop();
        var endMemory = GC.GetTotalMemory(false);
        
        return Task.FromResult(new ProcessingResult
        {
            ProcessedData = combined,
            ElapsedMilliseconds = sw.ElapsedMilliseconds,
            ThreadId = Thread.CurrentThread.ManagedThreadId,
            MemoryUsedBytes = endMemory - startMemory
        });
    }
    
    private List<byte[]> SplitIntoChunks(byte[] data, int chunkSize)
    {
        var chunks = new List<byte[]>();
        for (int i = 0; i < data.Length; i += chunkSize)
        {
            var size = Math.Min(chunkSize, data.Length - i);
            var chunk = new byte[size];
            Array.Copy(data, i, chunk, 0, size);
            chunks.Add(chunk);
        }
        return chunks;
    }
    
    private byte[] ProcessChunk(byte[] chunk, int intensity)
    {
        using var sha = SHA256.Create();
        var result = chunk;
        
        for (int i = 0; i < intensity; i++)
        {
            result = sha.ComputeHash(result);
        }
        
        return result;
    }
    
    private byte[] CombineChunks(byte[][] chunks)
    {
        var totalLength = chunks.Sum(c => c.Length);
        var combined = new byte[totalLength];
        int offset = 0;
        
        foreach (var chunk in chunks)
        {
            Array.Copy(chunk, 0, combined, offset, chunk.Length);
            offset += chunk.Length;
        }
        
        return combined;
    }
}

public class AsyncIoBoundProcessor : IWorkloadProcessor
{
    public string Name => "Asynchronous I/O-bound";
    
    public async Task<ProcessingResult> ProcessAsync(WorkloadData data, CancellationToken ct)
    {
        var sw = Stopwatch.StartNew();
        var startMemory = GC.GetTotalMemory(false);
        
        // Имитируем несколько I/O операций параллельно
        var ioTasks = new List<Task<byte[]>>();
        
        for (int i = 0; i < data.IoOperationsCount; i++)
        {
            ioTasks.Add(SimulateIoOperationAsync(data.Payload, i, ct));
        }
        
        // Ждём завершения всех I/O операций
        var ioResults = await Task.WhenAll(ioTasks);
        
        // Объединяем результаты
        var combined = CombineResults(ioResults);
        
        sw.Stop();
        var endMemory = GC.GetTotalMemory(false);
        
        return new ProcessingResult
        {
            ProcessedData = combined,
            ElapsedMilliseconds = sw.ElapsedMilliseconds,
            ThreadId = Thread.CurrentThread.ManagedThreadId,
            MemoryUsedBytes = endMemory - startMemory
        };
    }
    
    private async Task<byte[]> SimulateIoOperationAsync(byte[] data, int operationId, CancellationToken ct)
    {
        // Имитируем сетевую задержку - типичная латентность API
        await Task.Delay(Random.Shared.Next(50, 150), ct).ConfigureAwait(false);
        
        // Имитируем чтение/запись - допустим работа с файлом
        using var ms = new MemoryStream();
        await ms.WriteAsync(data, 0, data.Length, ct).ConfigureAwait(false);
        await ms.FlushAsync(ct).ConfigureAwait(false);
        
        // Имитируем обработку ответа
        ms.Position = 0;
        var result = new byte[ms.Length];
        await ms.ReadAsync(result, 0, result.Length, ct).ConfigureAwait(false);
        
        // Добавляем метку операции
        return result.Concat(BitConverter.GetBytes(operationId)).ToArray();
    }
    
    private byte[] CombineResults(byte[][] results)
    {
        return results.SelectMany(r => r).ToArray();
    }
}

public class HybridProcessor : IWorkloadProcessor
{
    public string Name => "Hybrid CPU+I/O";
    
    public async Task<ProcessingResult> ProcessAsync(WorkloadData data, CancellationToken ct)
    {
        var sw = Stopwatch.StartNew();
        var startMemory = GC.GetTotalMemory(false);
        
        // Фаза 1: I/O операция - загрузка данных
        var loadedData = await LoadDataAsync(data.Payload, ct).ConfigureAwait(false);
        
        // Фаза 2: CPU-intensive обработка (синхронно)
        var processedData = ProcessCpuBound(loadedData, data.ComputationIntensity, ct);
        
        // Фаза 3: I/O операция - сохранение результата
        var result = await SaveDataAsync(processedData, ct).ConfigureAwait(false);
        
        sw.Stop();
        var endMemory = GC.GetTotalMemory(false);
        
        return new ProcessingResult
        {
            ProcessedData = result,
            ElapsedMilliseconds = sw.ElapsedMilliseconds,
            ThreadId = Thread.CurrentThread.ManagedThreadId,
            MemoryUsedBytes = endMemory - startMemory
        };
    }
    
    private async Task<byte[]> LoadDataAsync(byte[] data, CancellationToken ct)
    {
        // Имитируем загрузку - например из базы данных
        await Task.Delay(100, ct).ConfigureAwait(false);
        
        using var ms = new MemoryStream();
        await ms.WriteAsync(data, 0, data.Length, ct).ConfigureAwait(false);
        return ms.ToArray();
    }
    
    private byte[] ProcessCpuBound(byte[] data, int intensity, CancellationToken ct)
    {
        // Синхронная CPU-intensive работа
        using var sha = SHA256.Create();
        var result = data;
        
        for (int i = 0; i < intensity; i++)
        {
            if (i % 10 == 0)
                ct.ThrowIfCancellationRequested();
                
            result = sha.ComputeHash(result);
        }
        
        return result;
    }
    
    private async Task<byte[]> SaveDataAsync(byte[] data, CancellationToken ct)
    {
        // Имитируем сохранение - например отправка в API
        await Task.Delay(80, ct).ConfigureAwait(false);
        
        using var ms = new MemoryStream();
        await ms.WriteAsync(data, 0, data.Length, ct).ConfigureAwait(false);
        await ms.FlushAsync(ct).ConfigureAwait(false);
        
        return ms.ToArray();
    }
}

public class BenchmarkCoordinator
{
    private readonly List<IWorkloadProcessor> _processors = new();
    private readonly ILogger _logger;
    
    public BenchmarkCoordinator(ILogger logger)
    {
        _logger = logger;
        
        // Регистрируем все процессоры
        _processors.Add(new SyncCpuBoundProcessor());
        _processors.Add(new ParallelCpuBoundProcessor());
        _processors.Add(new AsyncIoBoundProcessor());
        _processors.Add(new HybridProcessor());
    }
    
    public async Task<BenchmarkReport> RunBenchmarksAsync(
        WorkloadData data, 
        int iterations,
        CancellationToken ct)
    {
        var report = new BenchmarkReport();
        
        _logger.LogInformation($"Starting benchmark with {iterations} iterations");
        _logger.LogInformation($"Payload size: {data.Payload.Length} bytes");
        _logger.LogInformation($"Computation intensity: {data.ComputationIntensity}");
        _logger.LogInformation($"I/O operations: {data.IoOperationsCount}");
        
        foreach (var processor in _processors)
        {
            _logger.LogInformation($"\nTesting: {processor.Name}");
            
            var results = new List<ProcessingResult>();
            var sw = Stopwatch.StartNew();
            
            // Прогрев - первый запуск может быть медленнее из-за JIT
            await processor.ProcessAsync(data, ct);
            
            // Реальные измерения
            for (int i = 0; i < iterations; i++)
            {
                try
                {
                    var result = await processor.ProcessAsync(data, ct);
                    results.Add(result);
                    
                    _logger.LogDebug($"Iteration {i + 1}: {result.ElapsedMilliseconds}ms, " +
                                   $"Thread: {result.ThreadId}, " +
                                   $"Memory: {result.MemoryUsedBytes / 1024}KB");
                }
                catch (OperationCanceledException)
                {
                    _logger.LogWarning($"Benchmark cancelled at iteration {i + 1}");
                    break;
                }
            }
            
            sw.Stop();
            
            // Вычисляем статистику
            var stats = CalculateStatistics(processor.Name, results, sw.Elapsed);
            report.ProcessorStats.Add(stats);
            
            _logger.LogInformation($"Completed: Avg {stats.AverageTimeMs:F2}ms, " +
                                 $"Total {stats.TotalTimeMs}ms, " +
                                 $"Throughput {stats.ThroughputPerSecond:F0} ops/s");
        }
        
        return report;
    }
    
    private ProcessorStatistics CalculateStatistics(
        string name, 
        List<ProcessingResult> results, 
        TimeSpan totalTime)
    {
        var times = results.Select(r => r.ElapsedMilliseconds).OrderBy(t => t).ToArray();
        var memoryUsage = results.Select(r => r.MemoryUsedBytes).ToArray();
        
        return new ProcessorStatistics
        {
            ProcessorName = name,
            Iterations = results.Count,
            TotalTimeMs = (long)totalTime.TotalMilliseconds,
            AverageTimeMs = times.Average(),
            MedianTimeMs = times[times.Length / 2],
            MinTimeMs = times.First(),
            MaxTimeMs = times.Last(),
            P95TimeMs = times[(int)(times.Length * 0.95)],
            P99TimeMs = times[(int)(times.Length * 0.99)],
            AverageMemoryBytes = (long)memoryUsage.Average(),
            ThroughputPerSecond = results.Count / totalTime.TotalSeconds,
            UniqueThreadsUsed = results.Select(r => r.ThreadId).Distinct().Count()
        };
    }
}
 
public class BenchmarkReport
{
    public List<ProcessorStatistics> ProcessorStats { get; set; } = new();
    
    public void PrintComparison()
    {
        Console.WriteLine("\n=== Benchmark Results Comparison ===\n");
        Console.WriteLine($"{"Processor",-30} {"Avg (ms)",10} {"P95 (ms)",10} {"Throughput",12} {"Threads",8}");
        Console.WriteLine(new string('-', 75));
        
        foreach (var stat in ProcessorStats.OrderBy(s => s.AverageTimeMs))
        {
            Console.WriteLine($"{stat.ProcessorName,-30} " +
                            $"{stat.AverageTimeMs,10:F2} " +
                            $"{stat.P95TimeMs,10:F2} " +
                            $"{stat.ThroughputPerSecond,12:F0} " +
                            $"{stat.UniqueThreadsUsed,8}");
        }
        
        // Находим самый быстрый
        var fastest = ProcessorStats.OrderBy(s => s.AverageTimeMs).First();
        Console.WriteLine($"\nFastest: {fastest.ProcessorName}");
        
        // Показываем насколько остальные медленнее
        foreach (var stat in ProcessorStats.Where(s => s != fastest))
        {
            var slowdown = stat.AverageTimeMs / fastest.AverageTimeMs;
            Console.WriteLine($"{stat.ProcessorName}: {slowdown:F2}x slower");
        }
    }
}
 
public class ProcessorStatistics
{
    public string ProcessorName { get; set; }
    public int Iterations { get; set; }
    public long TotalTimeMs { get; set; }
    public double AverageTimeMs { get; set; }
    public long MedianTimeMs { get; set; }
    public long MinTimeMs { get; set; }
    public long MaxTimeMs { get; set; }
    public long P95TimeMs { get; set; }
    public long P99TimeMs { get; set; }
    public long AverageMemoryBytes { get; set; }
    public double ThroughputPerSecond { get; set; }
    public int UniqueThreadsUsed { get; set; }
}

class Program
{
    static async Task Main(string[] args)
    {
        // Настраиваем логирование
        using var loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddConsole();
            builder.SetMinimumLevel(LogLevel.Information);
        });
        var logger = loggerFactory.CreateLogger<BenchmarkCoordinator>();
        
        // Готовим тестовые данные
        var payload = new byte[1024 * 100]; // 100 КБ
        new Random(42).NextBytes(payload);
        
        var workload = new WorkloadData
        {
            Payload = payload,
            ComputationIntensity = 50, // Средняя нагрузка
            IoOperationsCount = 5
        };
        
        // Создаём координатор и запускаем тесты
        var coordinator = new BenchmarkCoordinator(logger);
        var cts = new CancellationTokenSource();
        
        // Обрабатываем Ctrl+C для корректной отмены
        Console.CancelKeyPress += (s, e) =>
        {
            e.Cancel = true;
            cts.Cancel();
            logger.LogWarning("Cancellation requested...");
        };
        
        try
        {
            var report = await coordinator.RunBenchmarksAsync(
                workload, 
                iterations: 20, 
                cts.Token);
            
            // Выводим сравнительный отчёт
            report.PrintComparison();
        }
        catch (OperationCanceledException)
        {
            logger.LogInformation("Benchmark cancelled by user");
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Benchmark failed");
        }
        
        Console.WriteLine("\nPress any key to exit...");
        Console.ReadKey();
    }
}

// Определяем оптимальное количество потоков с учётом виртуализации
public static class OptimalParallelism
{
    private static int? _cachedValue;
    
    public static int GetOptimalDegree()
    {
        if (_cachedValue.hasValue)
            return _cachedValue.Value;
            
        var processorCount = Environment.ProcessorCount;
        
        // Эвристика: если процессоров больше 16 и мы в облаке,
        // возможно это HT потоки, делим пополам
        if (processorCount > 16 && IsRunningInCloud())
        {
            _cachedValue = processorCount / 2;
        }
        else
        {
            _cachedValue = processorCount;
        }
        
        return _cachedValue.Value;
    }
    
    private static bool IsRunningInCloud()
    {
        // Простая проверка по переменным окружения
        return Environment.GetEnvironmentVariable("AWS_EXECUTION_ENV") != null ||
               Environment.GetEnvironmentVariable("WEBSITE_INSTANCE_ID") != null || // Azure
               File.Exists("/sys/class/dmi/id/product_name") && // GCP
               File.ReadAllText("/sys/class/dmi/id/product_name").Contains("Google");
    }
}

// Пул для переиспользования буферов
public class BufferPool
{
    private readonly ConcurrentBag<byte[]> _buffers = new();
    private readonly int _bufferSize;
    private readonly int _maxPoolSize;
    
    public BufferPool(int bufferSize, int maxPoolSize = 100)
    {
        _bufferSize = bufferSize;
        _maxPoolSize = maxPoolSize;
    }
    
    public byte[] Rent()
    {
        if (_buffers.TryTake(out var buffer))
            return buffer;
            
        return new byte[_bufferSize];
    }
    
    public void Return(byte[] buffer)
    {
        if (buffer.Length != _bufferSize)
            return; // Не тот размер, не возвращаем
            
        if (_buffers.Count < _maxPoolSize)
        {
            Array.Clear(buffer, 0, buffer.Length); // Очищаем данные
            _buffers.Add(buffer);
        }
    }
}
 
// Модифицированный процессор с pooling
public class PooledCpuBoundProcessor : IWorkloadProcessor
{
    private static readonly BufferPool _bufferPool = new(1024 * 64);
    
    public string Name => "CPU-bound with Buffer Pooling";
    
    public Task<ProcessingResult> ProcessAsync(WorkloadData data, CancellationToken ct)
    {
        var sw = Stopwatch.StartNew();
        var buffer = _bufferPool.Rent();
        
        try
        {
            // Работа с переиспользуемым буфером
            var processed = ProcessWithBuffer(data.Payload, buffer, ct);
            
            sw.Stop();
            return Task.FromResult(new ProcessingResult
            {
                ProcessedData = processed,
                ElapsedMilliseconds = sw.ElapsedMilliseconds,
                ThreadId = Thread.CurrentThread.ManagedThreadId
            });
        }
        finally
        {
            _bufferPool.Return(buffer);
        }
    }
    
    private byte[] ProcessWithBuffer(byte[] data, byte[] buffer, CancellationToken ct)
    {
        // Используем buffer для промежуточных вычислений
        using var sha = SHA256.Create();
        return sha.ComputeHash(data);
    }
}

public class RealTimeMonitor : IDisposable
{
    private readonly Timer _timer;
    private readonly PerformanceCounter _cpuCounter;
    private int _completedOperations;
    private readonly object _lock = new();
    
    public RealTimeMonitor()
    {
        _cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
        _timer = new Timer(UpdateDisplay, null, 0, 500); // Обновляем каждые 500мс
    }
    
    public void RecordCompletion()
    {
        Interlocked.Increment(ref _completedOperations);
    }
    
    private void UpdateDisplay(object state)
    {
        var cpu = _cpuCounter.NextValue();
        var threadCount = Process.GetCurrentProcess().Threads.Count;
        var memory = GC.GetTotalMemory(false) / (1024 * 1024);
        
        lock (_lock)
        {
            Console.SetCursorPosition(0, Console.CursorTop);
            Console.Write($"Completed: {_completedOperations,6} | " +
                         $"CPU: {cpu,5:F1}% | " +
                         $"Threads: {threadCount,3} | " +
                         $"Memory: {memory,5}MB     ");
        }
    }
    
    public void Dispose()
    {
        _timer?.Dispose();
        _cpuCounter?.Dispose();
    }
}

// Адаптивный процессор - выбирает стратегию по размеру данных
public class AdaptiveProcessor : IWorkloadProcessor
{
    private readonly SyncCpuBoundProcessor _syncProcessor = new();
    private readonly AsyncIoBoundProcessor _asyncProcessor = new();
    private const int THRESHOLD_BYTES = 150 * 1024;
    
    public string Name => "Adaptive (Sync/Async)";
    
    public Task<ProcessingResult> ProcessAsync(WorkloadData data, CancellationToken ct)
    {
        // Выбираем стратегию на основе размера данных
        if (data.Payload.Length < THRESHOLD_BYTES)
        {
            return _syncProcessor.ProcessAsync(data, ct);
        }
        else
        {
            return _asyncProcessor.ProcessAsync(data, ct);
        }
    }
}

public async Task RunStressTestAsync(int concurrentRequests, TimeSpan duration)
{
    var cts = new CancellationTokenSource(duration);
    var activeTasks = new List<Task>();
    var completedCount = 0;
    var failedCount = 0;
    
    _logger.LogInformation($"Starting stress test: {concurrentRequests} concurrent requests for {duration.TotalSeconds}s");
    
    while (!cts.Token.IsCancellationRequested)
    {
        // Поддерживаем постоянный уровень конкуренции
        while (activeTasks.Count < concurrentRequests)
        {
            var data = GenerateRandomWorkload();
            var processor = _processors[Random.Shared.Next(_processors.Count)];
            
            var task = Task.Run(async () =>
            {
                try
                {
                    await processor.ProcessAsync(data, cts.Token);
                    Interlocked.Increment(ref completedCount);
                }
                catch
                {
                    Interlocked.Increment(ref failedCount);
                }
            });
            
            activeTasks.Add(task);
        }
        
        // Удаляем завершённые задачи
        activeTasks.RemoveAll(t => t.IsCompleted);
        
        await Task.Delay(10, cts.Token);
    }
    
    await Task.WhenAll(activeTasks);
    
    _logger.LogInformation($"Stress test completed: {completedCount} succeeded, {failedCount} failed");
    _logger.LogInformation($"Throughput: {completedCount / duration.TotalSeconds:F0} ops/s");
}