Многопоточность в C#: Класс Thread

using System;
using System.Threading;
 
public class Program
{
    public static void Main()
    {
        // Создаем экземпляр Thread и передаем ему метод для выполнения
        Thread thread = new Thread(WorkerMethod);
        
        // Запускаем поток
        thread.Start();
        
        // Этот код выполняется в главном потоке параллельно с WorkerMethod
        Console.WriteLine("Главный поток продолжает работу!");
        Console.ReadLine();
    }
    
    private static void WorkerMethod()
    {
        // Код, который будет выполняться в отдельном потоке
        Console.WriteLine("Привет из отдельного потока!");
    }
}

   public delegate void ThreadStart();

   public delegate void ParameterizedThreadStart(object obj);

Thread thread = new Thread(ParameterizedMethod);
thread.Start("Привет, поток!"); // Передаем строку в качестве параметра
 
// ...
 
private static void ParameterizedMethod(object message)
{
    string msg = message as string;
    Console.WriteLine(msg);
}

bool isRunning = thread.IsAlive;

thread.Join(); // Блокирует вызывающий поток до завершения thread

bool completed = thread.Join(1000); // Ждем не более одной секунды

thread.IsBackground = true;

thread.Name = "Рабочий поток №1";

private static void SafeMethod()
{
    try
    {
        // Опасный код, который может вызвать исключение
        int result = 10 / 0; // Вызовет DivideByZeroException
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Перехвачено исключение: {ex.Message}");
    }
}

Thread.CurrentThread.CurrentCulture = new CultureInfo("ru-RU");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("ru-RU");

int threadId = Thread.CurrentThread.ManagedThreadId;
Console.WriteLine($"Этот код выполняется в потоке с ID: {threadId}");

thread.Priority = ThreadPriority.AboveNormal;

Task task = Task.Run(() => Console.WriteLine("Выполняется в отдельном потоке"));
await task; // Ждем завершения задачи

ThreadPool.QueueUserWorkItem(state => {
    Console.WriteLine("Выполняется в потоке из пула");
});

// Приостановка текущего потока на 1 секунду
Thread.Sleep(1000);

Thread.Sleep(TimeSpan.FromSeconds(1));

// Передать оставшееся время другим потокам
Thread.Sleep(0);

Thread worker = new Thread(DoWork);
worker.Start();
 
// Блокировка текущего потока до завершения worker
worker.Join();
Console.WriteLine("Рабочий поток завершился");

// Ждать завершения потока максимум 5 секунд
bool completed = worker.Join(5000);
if (completed)
    Console.WriteLine("Рабочий поток завершился в течение 5 секунд");
else
    Console.WriteLine("Истекло время ожидания");

Thread worker = new Thread(() => 
{
    try
    {
        Thread.Sleep(Timeout.Infinite);  // Бесконечное ожидание
    }
    catch (ThreadInterruptedException ex)
    {
        Console.WriteLine("Поток был прерван: " + ex.Message);
    }
});
 
worker.Start();
Thread.Sleep(1000);  // Даём потоку время на запуск
worker.Interrupt();  // Прерываем поток

thread.Priority = ThreadPriority.Highest;

void DemonstratePriorities()
{
    int[] counters = new int[3];
    bool running = true;
 
    // Создаём три потока с разными приоритетами
    Thread high = new Thread(() => { while(running) counters[0]++; });
    Thread normal = new Thread(() => { while(running) counters[1]++; });
    Thread low = new Thread(() => { while(running) counters[2]++; });
 
    high.Priority = ThreadPriority.Highest;
    normal.Priority = ThreadPriority.Normal;
    low.Priority = ThreadPriority.Lowest;
 
    high.Start(); normal.Start(); low.Start();
    
    Thread.Sleep(1000);  // Даём потокам поработать секунду
    running = false;     // Останавливаем все потоки
    
    // Ждём завершения всех потоков
    high.Join(); normal.Join(); low.Join();
    
    // Выводим результаты
    Console.WriteLine($"Высокий приоритет: {counters[0]:N0}");
    Console.WriteLine($"Нормальный приоритет: {counters[1]:N0}");
    Console.WriteLine($"Низкий приоритет: {counters[2]:N0}");
}

Thread daemon = new Thread(DoBackgroundWork);
daemon.IsBackground = true;
daemon.Start();

static void Main()
{
    Thread foreground = new Thread(() => 
    {
        // Этот поток продолжит выполнение после завершения Main
        Thread.Sleep(2000);
        Console.WriteLine("Обычный поток завершился");
    });
    
    Thread background = new Thread(() => 
    {
        // Этот поток будет автоматически закрыт при завершении процесса
        Thread.Sleep(2000);
        Console.WriteLine("Фоновый поток завершился");
    });
    
    background.IsBackground = true;
    
    foreground.Start();
    background.Start();
    
    Console.WriteLine("Метод Main завершается");
    // Программа продолжит работу, пока foreground не завершится
    // background может быть закрыт раньше, если foreground завершится быстрее
}

class SafeThreadStop
{
    private volatile bool _shouldStop = false;
    
    public void DoWork()
    {
        Thread worker = new Thread(() => 
        {
            while (!_shouldStop)
            {
                // Выполнение работы
                Console.WriteLine("Поток выполняет работу...");
                Thread.Sleep(100);
            }
            Console.WriteLine("Поток корректно завершён");
        });
        
        worker.Start();
        
        // Даём потоку поработать 1 секунду
        Thread.Sleep(1000);
        
        // Сигнал потоку о завершении
        _shouldStop = true;
        
        // Ждём завершения
        worker.Join();
    }
}

static void ThreadDebuggingExample()
{
    for (int i = 0; i < 3; i++)
    {
        int threadNumber = i; // Локальная копия для замыкания
        Thread t = new Thread(() => 
        {
            // Именование помогает при отладке
            Thread.CurrentThread.Name = $"Рабочий поток {threadNumber}";
            
            // Точка останова здесь позволит изучить все потоки в окне "Потоки"
            Console.WriteLine($"Поток {Thread.CurrentThread.Name} запущен");
            Thread.Sleep(1000 * threadNumber);
        });
        t.Start();
    }
}

// Условие точки останова для конкретного потока
Thread.CurrentThread.Name == "Рабочий поток 2"

void DemonstrateAbortProblems()
{
    object lockObj = new object();
    bool resourceAcquired = false;
    
    Thread problematicThread = new Thread(() => 
    {
        try
        {
            lock (lockObj)
            {
                resourceAcquired = true;
                Console.WriteLine("Ресурс захвачен");
                
                // Представим, что здесь выполняется длительная операция
                while (true)
                {
                    Thread.Sleep(100);
                }
                
                // До этой точки выполнение никогда не дойдёт при вызове Abort()
            } // Блокировка не будет освобождена при Abort()
        }
        catch (ThreadAbortException ex)
        {
            Console.WriteLine($"Поток прерван: {ex.Message}");
            // Попытка очистки, но ThreadAbortException может возникнуть снова здесь
        }
        finally
        {
            // ThreadAbortException может возникнуть и здесь,
            // нарушая логику очистки ресурсов
            Console.WriteLine("Finally выполняется, но может быть прерван");
        }
    });
    
    problematicThread.Start();
    Thread.Sleep(500); // Даём время захватить блокировку
    
    // ОПАСНО: может привести к повреждению данных и взаимоблокировкам
    problematicThread.Abort();
    
    Thread.Sleep(500);
    
    // Этот поток будет заблокирован навсегда, так как lockObj не был освобождён
    Thread deadlockedThread = new Thread(() => 
    {
        Console.WriteLine("Попытка захватить ресурс...");
        lock (lockObj)
        {
            Console.WriteLine("Ресурс захвачен (это сообщение никогда не появится)");
        }
    });
    
    deadlockedThread.Start();
}

using System.Threading;
 
class CooperativeCancellation
{
    private CancellationTokenSource _cts = new CancellationTokenSource();
    
    public void StartLongOperation()
    {
        Thread t = new Thread(() => DoWork(_cts.Token));
        t.Start();
    }
    
    public void StopOperation()
    {
        _cts.Cancel();
    }
    
    private void DoWork(CancellationToken token)
    {
        try
        {
            while (!token.IsCancellationRequested)
            {
                // Выполнение работы
                Console.WriteLine("Работа выполняется...");
                Thread.Sleep(100);
                
                // Периодически проверяем токен отмены
                token.ThrowIfCancellationRequested();
            }
        }
        catch (OperationCanceledException)
        {
            // Корректная обработка отмены
            Console.WriteLine("Операция отменена корректно");
        }
        finally
        {
            // Гарантированная очистка ресурсов
            Console.WriteLine("Ресурсы освобождены");
        }
    }
}

public class Counter
{
    private int _count = 0;
    
    public void Increment()
    {
        _count++; // Не атомарная операция!
    }
    
    public int Value => _count;
}

public class ThreadSafeCounter
{
    private int _count = 0;
    private readonly object _lockObject = new object();
    
    public void Increment()
    {
        lock (_lockObject)
        {
            _count++;
        }
    }
    
    public int Value
    {
        get
        {
            lock (_lockObject)
            {
                return _count;
            }
        }
    }
}

public void ComplexOperation()
{
    bool lockTaken = false;
    try
    {
        Monitor.Enter(_lockObject, ref lockTaken);
        // Критическая секция
    }
    finally
    {
        if (lockTaken)
            Monitor.Exit(_lockObject);
    }
}

using System.Threading;
 
class MutexExample
{
    static Mutex _mutex = new Mutex(false, "GlobalMutexName");
    
    public void SafeOperation()
    {
        try
        {
            _mutex.WaitOne();
            // Критическая секция
            Console.WriteLine("Критическая секция выполняется потоком " + 
                             Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1000); // Имитация работы
        }
        finally
        {
            _mutex.ReleaseMutex();
        }
    }
}

private SemaphoreSlim _semaphore = new SemaphoreSlim(3); // Макс. 3 потока
 
public async Task LimitedAccessAsync()
{
    try
    {
        await _semaphore.WaitAsync();
        // До 3 потоков могут одновременно выполнять этот код
        await Task.Delay(1000); // Имитация асинхронной работы
    }
    finally
    {
        _semaphore.Release();
    }
}

private ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();
private Dictionary<int, string> _cache = new Dictionary<int, string>();
 
public string GetItem(int id)
{
    try
    {
        _rwLock.EnterReadLock();
        if (_cache.TryGetValue(id, out string value))
            return value;
    }
    finally
    {
        _rwLock.ExitReadLock();
    }
    
    try
    {
        _rwLock.EnterWriteLock();
        // Проверяем ещё раз, так как другой поток мог добавить значение
        if (_cache.TryGetValue(id, out string value))
            return value;
        
        // Получаем данные (например, из БД)
        value = "Data for ID " + id;
        _cache[id] = value;
        return value;
    }
    finally
    {
        _rwLock.ExitWriteLock();
    }
}

private ManualResetEvent _dataReadyEvent = new ManualResetEvent(false);
private List<int> _data = new List<int>();
 
public void ProduceData()
{
    // Готовим данные
    for (int i = 0; i < 10; i++)
    {
        _data.Add(i);
        Thread.Sleep(100); // Имитация работы
    }
    
    // Сигнализируем, что данные готовы
    _dataReadyEvent.Set();
}
 
public void ConsumeData()
{
    // Ждём, пока данные будут готовы
    _dataReadyEvent.WaitOne();
    
    // Используем данные
    foreach (var item in _data)
    {
        Console.WriteLine(item);
    }
}

class SharedState
{
    private readonly object _lock = new object();
    private Queue<string> _messageQueue = new Queue<string>();
    
    public void EnqueueMessage(string message)
    {
        lock (_lock)
        {
            _messageQueue.Enqueue(message);
            Monitor.Pulse(_lock); // Уведомляем ожидающий поток
        }
    }
    
    public string DequeueMessage()
    {
        lock (_lock)
        {
            while (_messageQueue.Count == 0)
                Monitor.Wait(_lock); // Ждём, пока появится сообщение
            
            return _messageQueue.Dequeue();
        }
    }
}

private BlockingCollection<int> _items = new BlockingCollection<int>(new ConcurrentQueue<int>());
 
public void Producer()
{
    for (int i = 0; i < 100; i++)
    {
        _items.Add(i);
        Thread.Sleep(10); // Имитация работы
    }
    _items.CompleteAdding(); // Сигнализируем, что добавление завершено
}
 
public void Consumer()
{
    foreach (var item in _items.GetConsumingEnumerable())
    {
        Console.WriteLine($"Обработан элемент: {item}");
        Thread.Sleep(50); // Обработка занимает больше времени
    }
}

private ConcurrentDictionary<string, int> _stats = new ConcurrentDictionary<string, int>();
 
public void UpdateStats(string key)
{
    // Потокобезопасное увеличение счётчика или добавление нового ключа
    _stats.AddOrUpdate(key, 1, (k, v) => v + 1);
}

private readonly object _lock1 = new object();
private readonly object _lock2 = new object();
 
public void MethodA()
{
    lock (_lock1)
    {
        Thread.Sleep(1000); // Имитируем работу
        lock (_lock2)
        {
            Console.WriteLine("MethodA выполнен");
        }
    }
}
 
public void MethodB()
{
    lock (_lock2)
    {
        Thread.Sleep(1000); // Имитируем работу
        lock (_lock1)
        {
            Console.WriteLine("MethodB выполнен");
        }
    }
}

public void SafeMethodA()
{
    lock (_lock1)
    {
        lock (_lock2)
        {
            Console.WriteLine("SafeMethodA выполнен");
        }
    }
}
 
public void SafeMethodB()
{
    lock (_lock1) // Используем тот же порядок блокировок, что и в SafeMethodA
    {
        lock (_lock2)
        {
            Console.WriteLine("SafeMethodB выполнен");
        }
    }
}

public void TryWithTimeout()
{
    bool lockTaken = false;
    try
    {
        Monitor.TryEnter(_lock1, 1000, ref lockTaken);
        if (lockTaken)
        {
            // Продолжаем работу
        }
        else
        {
            Console.WriteLine("Не удалось получить блокировку в течение таймаута");
        }
    }
    finally
    {
        if (lockTaken)
            Monitor.Exit(_lock1);
    }
}

public void CoordinateThreads(int threadCount)
{
    var countdown = new CountdownEvent(threadCount);
    
    for (int i = 0; i < threadCount; i++)
    {
        int threadId = i; // Локальная копия для замыкания
        new Thread(() => 
        {
            Console.WriteLine($"Поток {threadId} начал работу");
            Thread.Sleep(1000 * threadId); // Разное время работы
            Console.WriteLine($"Поток {threadId} завершил работу");
            countdown.Signal(); // Уменьшаем счётчик
        }).Start();
    }
    
    // Ждём, пока все потоки завершат работу
    countdown.Wait();
    Console.WriteLine("Все потоки завершены");
}

public class PiCalculator
{
    private int _totalPoints;
    private int _pointsInCircle;
    private readonly object _lockObject = new object();
    private volatile bool _shouldStop;
 
    public double CalculatePi(int iterations, int threadCount)
    {
        _totalPoints = 0;
        _pointsInCircle = 0;
        _shouldStop = false;
        
        // Создаём и запускаем рабочие потоки
        Thread[] threads = new Thread[threadCount];
        
        for (int i = 0; i < threadCount; i++)
        {
            threads[i] = new Thread(() => WorkerMethod(iterations / threadCount));
            threads[i].Start();
        }
        
        // Ожидаем завершения всех потоков
        foreach (var thread in threads)
            thread.Join();
        
        // Вычисляем приближенное значение π
        return 4.0 * _pointsInCircle / _totalPoints;
    }
    
    private void WorkerMethod(int iterations)
    {
        Random rand = new Random();
        int localPointsInCircle = 0;
        int localTotalPoints = 0;
        
        for (int i = 0; i < iterations && !_shouldStop; i++)
        {
            double x = rand.NextDouble();
            double y = rand.NextDouble();
            
            if (x * x + y * y <= 1)
                localPointsInCircle++;
                
            localTotalPoints++;
        }
        
        // Обновляем общие счётчики под блокировкой
        lock (_lockObject)
        {
            _pointsInCircle += localPointsInCircle;
            _totalPoints += localTotalPoints;
        }
    }
    
    public void Stop()
    {
        _shouldStop = true;
    }
}

public class FileProcessor
{
    private ConcurrentDictionary<string, long> _fileSizes = new ConcurrentDictionary<string, long>();
    private int _processedFiles;
    private readonly object _lockObject = new object();
    
    public void ProcessDirectory(string path, int maxThreads)
    {
        string[] files = Directory.GetFiles(path, "*", SearchOption.AllDirectories);
        
        _processedFiles = 0;
        
        // Контролируем количество одновременно работающих потоков
        using (SemaphoreSlim semaphore = new SemaphoreSlim(maxThreads))
        {
            List<Thread> threads = new List<Thread>();
            
            foreach (string file in files)
            {
                semaphore.Wait(); // Ждём, пока освободится слот
                
                Thread t = new Thread(() =>
                {
                    try
                    {
                        ProcessFile(file);
                    }
                    finally
                    {
                        semaphore.Release(); // Освобождаем слот
                    }
                });
                
                threads.Add(t);
                t.Start();
            }
            
            // Ждём завершения всех потоков
            foreach (var thread in threads)
                thread.Join();
        }
        
        // Выводим результаты
        Console.WriteLine($"Обработано файлов: {_processedFiles}");
        Console.WriteLine($"Топ-5 самых больших файлов:");
        
        foreach (var pair in _fileSizes.OrderByDescending(p => p.Value).Take(5))
        {
            Console.WriteLine($"{pair.Key}: {pair.Value / 1024} KB");
        }
    }
    
    private void ProcessFile(string filePath)
    {
        try
        {
            // Имитация обработки файла
            Thread.Sleep(10);
            
            FileInfo info = new FileInfo(filePath);
            _fileSizes[filePath] = info.Length;
            
            lock (_lockObject)
            {
                _processedFiles++;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ошибка при обработке {filePath}: {ex.Message}");
        }
    }
}

public class BankAccount
{
    private int _balance;
    
    public void Deposit(int amount)
    {
        _balance += amount; // Небезопасная операция
    }
    
    public void Withdraw(int amount)
    {
        if (_balance >= amount) // Проверка и изменение не атомарны
            _balance -= amount;
    }
    
    public int Balance => _balance;
}

public class ThreadSafeBankAccount
{
    private int _balance;
    private readonly object _lockObject = new object();
    
    public void Deposit(int amount)
    {
        lock (_lockObject)
        {
            _balance += amount;
        }
    }
    
    public bool Withdraw(int amount)
    {
        lock (_lockObject)
        {
            if (_balance >= amount)
            {
                _balance -= amount;
                return true;
            }
            return false;
        }
    }
    
    public int Balance
    {
        get
        {
            lock (_lockObject)
            {
                return _balance;
            }
        }
    }
}

void TroubleWithExceptions()
{
    Thread t = new Thread(() =>
    {
        throw new InvalidOperationException("Ошибка в потоке");
    });
    
    t.Start();
    t.Join(); // Ждём завершения потока, но исключение не будет перехвачено
    Console.WriteLine("Готово"); // Этот код выполнится, несмотря на исключение
}

void HandlingThreadExceptions()
{
    Exception threadException = null;
    
    Thread t = new Thread(() =>
    {
        try
        {
            throw new InvalidOperationException("Ошибка в потоке");
        }
        catch (Exception ex)
        {
            threadException = ex;
        }
    });
    
    t.Start();
    t.Join();
    
    if (threadException != null)
        throw new Exception("Ошибка в рабочем потоке", threadException);
    
    Console.WriteLine("Успешное завершение");
}

class DeadlockDemo
{
    private readonly object _resourceA = new object();
    private readonly object _resourceB = new object();
    
    public void OperationA()
    {
        lock (_resourceA)
        {
            Console.WriteLine("Поток A захватил ресурс A");
            Thread.Sleep(1000); // Имитация работы
            
            lock (_resourceB)
            {
                Console.WriteLine("Поток A захватил ресурс B");
            }
        }
    }
    
    public void OperationB()
    {
        lock (_resourceB)
        {
            Console.WriteLine("Поток B захватил ресурс B");
            Thread.Sleep(1000); // Имитация работы
            
            lock (_resourceA)
            {
                Console.WriteLine("Поток B захватил ресурс A");
            }
        }
    }
}

void TooManyThreads(int taskCount)
{
    for (int i = 0; i < taskCount; i++)
    {
        new Thread(() => {
            // Что-то делаем
            Thread.Sleep(1000);
        }).Start();
    }
    // Если taskCount очень большой, производительность может упасть
}

void BetterApproach(int taskCount)
{
    // Настраиваем ParallelOptions для ограничения параллелизма
    var options = new ParallelOptions
    {
        MaxDegreeOfParallelism = Environment.ProcessorCount
    };
    
    Parallel.For(0, taskCount, options, i =>
    {
        // Что-то делаем
        Thread.Sleep(1000);
    });
}

[TestMethod]
public void StressTestThreadSafety()
{
    ThreadSafeBankAccount account = new ThreadSafeBankAccount();
    const int threadCount = 10;
    const int operationsPerThread = 1000;
    bool failed = false;
    
    Thread[] threads = new Thread[threadCount];
    for (int i = 0; i < threadCount; i++)
    {
        threads[i] = new Thread(() =>
        {
            for (int j = 0; j < operationsPerThread; j++)
            {
                account.Deposit(1);
                bool success = account.Withdraw(1);
                if (!success)
                    failed = true;
            }
        });
        threads[i].Start();
    }
    
    foreach (var thread in threads)
        thread.Join();
    
    Assert.IsFalse(failed, "Некоторые операции снятия не удались");
    Assert.AreEqual(0, account.Balance, "Баланс должен быть 0");
}

class InstrumentedAccount
{
    private int _balance;
    private readonly object _lock = new object();
    private List<string> _operationLog = new List<string>();
    
    public void Deposit(int amount, int threadId)
    {
        lock (_lock)
        {
            _operationLog.Add($"T{threadId}: Депозит {amount} начат. Баланс={_balance}");
            _balance += amount;
            _operationLog.Add($"T{threadId}: Депозит {amount} завершен. Баланс={_balance}");
        }
    }
    
    public bool Withdraw(int amount, int threadId)
    {
        lock (_lock)
        {
            _operationLog.Add($"T{threadId}: Снятие {amount} начато. Баланс={_balance}");
            if (_balance >= amount)
            {
                _balance -= amount;
                _operationLog.Add($"T{threadId}: Снятие {amount} успешно. Баланс={_balance}");
                return true;
            }
            _operationLog.Add($"T{threadId}: Снятие {amount} неудачно. Баланс={_balance}");
            return false;
        }
    }
    
    public List<string> GetOperationLog()
    {
        lock (_lock)
        {
            return new List<string>(_operationLog);
        }
    }
    
    public int Balance
    {
        get
        {
            lock (_lock)
            {
                return _balance;
            }
        }
    }
}

void MeasureThreadPerformance(int iterations, int threadCount)
{
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    
    // Однопоточное выполнение
    for (int i = 0; i < iterations; i++)
    {
        // Выполняем работу
        DoWork(i);
    }
    
    stopwatch.Stop();
    long singleThreadTime = stopwatch.ElapsedMilliseconds;
    Console.WriteLine($"Однопоточное время: {singleThreadTime} мс");
    
    // Многопоточное выполнение
    stopwatch.Restart();
    
    int itemsPerThread = iterations / threadCount;
    Thread[] threads = new Thread[threadCount];
    
    for (int t = 0; t < threadCount; t++)
    {
        int start = t * itemsPerThread;
        int end = (t == threadCount - 1) ? iterations : (t + 1) * itemsPerThread;
        
        threads[t] = new Thread(() =>
        {
            for (int i = start; i < end; i++)
            {
                DoWork(i);
            }
        });
        
        threads[t].Start();
    }
    
    foreach (var thread in threads)
        thread.Join();
    
    stopwatch.Stop();
    long multiThreadTime = stopwatch.ElapsedMilliseconds;
    Console.WriteLine($"Многопоточное время ({threadCount} потоков): {multiThreadTime} мс");
    
    double speedup = (double)singleThreadTime / multiThreadTime;
    Console.WriteLine($"Ускорение: {speedup:F2}x");
}
 
void DoWork(int value)
{
    // Имитация CPU-интенсивной работы
    double result = 0;
    for (int i = 0; i < 10000; i++)
    {
        result += Math.Sin(value * 0.01) * Math.Cos(value * 0.01);
    }
}

void MonitorThreadPool()
{
    // Получаем информацию о пуле потоков
    ThreadPool.GetMaxThreads(out int maxWorkerThreads, out int maxCompletionPortThreads);
    ThreadPool.GetAvailableThreads(out int availableWorkerThreads, out int availableCompletionPortThreads);
    
    int busyWorkerThreads = maxWorkerThreads - availableWorkerThreads;
    int busyCompletionPortThreads = maxCompletionPortThreads - availableCompletionPortThreads;
    
    Console.WriteLine($"Рабочие потоки: {busyWorkerThreads}/{maxWorkerThreads}");
    Console.WriteLine($"Потоки порта завершения: {busyCompletionPortThreads}/{maxCompletionPortThreads}");
    
    // Мониторинг производительности
    PerformanceCounter cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total");
    PerformanceCounter ramCounter = new PerformanceCounter("Memory", "Available MBytes");
    
    Console.WriteLine($"Загрузка CPU: {cpuCounter.NextValue()}%");
    Console.WriteLine($"Доступная память: {ramCounter.NextValue()} МБ");
}

public class ImageProcessor
{
    private readonly SemaphoreSlim _throttler;
    private readonly ConcurrentDictionary<string, byte[]> _processedImages = new ConcurrentDictionary<string, byte[]>();
    
    public ImageProcessor(int maxConcurrentOperations)
    {
        _throttler = new SemaphoreSlim(maxConcurrentOperations);
    }
    
    public async Task ProcessImagesAsync(List<string> imageUrls)
    {
        List<Task> tasks = new List<Task>();
        
        foreach (var url in imageUrls)
        {
            tasks.Add(ProcessSingleImageAsync(url));
        }
        
        await Task.WhenAll(tasks);
    }
    
    private async Task ProcessSingleImageAsync(string imageUrl)
    {
        try
        {
            await _throttler.WaitAsync();
            
            // Здесь мы используем Task, а не Thread напрямую,
            // так как это более подходит для I/O операций
            using (HttpClient client = new HttpClient())
            {
                // Загружаем изображение
                byte[] imageData = await client.GetByteArrayAsync(imageUrl);
                
                // Запускаем CPU-интенсивную обработку в отдельном потоке
                byte[] processedData = await Task.Run(() => ApplyImageFilter(imageData));
                
                // Сохраняем результат
                _processedImages[imageUrl] = processedData;
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ошибка при обработке {imageUrl}: {ex.Message}");
        }
        finally
        {
            _throttler.Release();
        }
    }
    
    private byte[] ApplyImageFilter(byte[] imageData)
    {
        // Имитация обработки изображения (в реальном приложении здесь был бы код фильтрации)
        Thread.Sleep(500); // Представим, что обработка занимает время
        
        // Для демонстрации просто возвращаем исходные данные
        return imageData;
    }
    
    public IReadOnlyDictionary<string, byte[]> GetProcessedImages()
    {
        return _processedImages;
    }
}
 
// Использование:
async Task Main()
{
    List<string> imageUrls = new List<string>
    {
        "https://example.com/image1.jpg",
        "https://example.com/image2.jpg",
        "https://example.com/image3.jpg",
        // ... больше URL-адресов
    };
    
    ImageProcessor processor = new ImageProcessor(maxConcurrentOperations: 3);
    await processor.ProcessImagesAsync(imageUrls);
    
    var results = processor.GetProcessedImages();
    Console.WriteLine($"Обработано {results.Count} изображений");
}

public class ThreadOptimizer
{
    private readonly int _processorCount;
    private readonly int _optimalThreadCount;
    
    public ThreadOptimizer()
    {
        _processorCount = Environment.ProcessorCount;
        
        // Для CPU-bound задач оптимальное число потоков обычно равно числу ядер
        _optimalThreadCount = _processorCount;
        
        // Для I/O-bound задач можно использовать больше потоков
        int ioThreadCount = _processorCount * 2;
        
        Console.WriteLine($"Количество процессоров: {_processorCount}");
        Console.WriteLine($"Оптимальное количество потоков для CPU-bound задач: {_optimalThreadCount}");
        Console.WriteLine($"Рекомендуемое количество потоков для I/O-bound задач: {ioThreadCount}");
    }
    
    public ParallelOptions GetCpuBoundParallelOptions()
    {
        return new ParallelOptions
        {
            MaxDegreeOfParallelism = _optimalThreadCount
        };
    }
    
    public void RunCpuBoundTask(Action<int> action, int iterations)
    {
        Parallel.For(0, iterations, GetCpuBoundParallelOptions(), action);
    }
    
    // Метод для тестирования разных степеней параллелизма
    public Dictionary<int, long> BenchmarkThreadCounts(Action<int> work, int iterations, int maxThreadsToTest)
    {
        Dictionary<int, long> results = new Dictionary<int, long>();
        
        for (int threads = 1; threads <= Math.Min(maxThreadsToTest, _processorCount * 4); threads++)
        {
            Stopwatch sw = Stopwatch.StartNew();
            
            int itemsPerThread = iterations / threads;
            CountdownEvent countdown = new CountdownEvent(threads);
            
            for (int t = 0; t < threads; t++)
            {
                int start = t * itemsPerThread;
                int end = (t == threads - 1) ? iterations : (t + 1) * itemsPerThread;
                
                new Thread(() => {
                    for (int i = start; i < end; i++)
                    {
                        work(i);
                    }
                    countdown.Signal();
                }).Start();
            }
            
            countdown.Wait();
            sw.Stop();
            
            results[threads] = sw.ElapsedMilliseconds;
            Console.WriteLine($"Потоков: {threads}, Время: {sw.ElapsedMilliseconds} мс");
        }
        
        int bestThreadCount = results.OrderBy(pair => pair.Value).First().Key;
        Console.WriteLine($"Лучший результат с {bestThreadCount} потоками");
        
        return results;
    }
}