using System.Threading;

var thread = new Thread(() =>
{
    Thread.Sleep(5000);  // потік зависне на 5 секунд
});

// Перед Start()
Console.WriteLine($"До Start(): {thread.ThreadState}");
// Виведе: Unstarted

thread.Start();
Thread.Sleep(100);  // Даємо потоку час почати виконуватись і зайти у Sleep

// Потік тепер у Sleep — стан WaitSleepJoin
Console.WriteLine($"Під час Sleep: {thread.ThreadState}");
// Виведе: WaitSleepJoin
// Або: Background, WaitSleepJoin (якщо IsBackground=true)

thread.Join();

Console.WriteLine($"Після Join: {thread.ThreadState}");
// Виведе: Stopped

// Порада: для перевірки чи потік завершився — використовуйте IsAlive
// замість ThreadState (більш читабельно)
Console.WriteLine($"IsAlive: {thread.IsAlive}");  // false після завершення

using System.Diagnostics;
using System.Threading;

int lowCount = 0, highCount = 0;
var sw = Stopwatch.StartNew();

// Потік з низьким пріоритетом
var lowPriority = new Thread(() =>
{
    while (sw.ElapsedMilliseconds < 3000)
        Interlocked.Increment(ref lowCount);
}) { Name = "Low", Priority = ThreadPriority.Lowest };

// Потік з високим пріоритетом
var highPriority = new Thread(() =>
{
    while (sw.ElapsedMilliseconds < 3000)
        Interlocked.Increment(ref highCount);
}) { Name = "High", Priority = ThreadPriority.Highest };

lowPriority.Start();
highPriority.Start();

lowPriority.Join();
highPriority.Join();

Console.WriteLine($"Low priority:  {lowCount:N0} iterations");
Console.WriteLine($"High priority: {highCount:N0} iterations");
Console.WriteLine($"Ratio: {(double)highCount / lowCount:F1}x більше у High");
// На завантаженій системі: high виконає у 5-20x більше ітерацій

// Ілюстрація проблеми Priority Inversion
// (спрощена — реальна ситуація складніша)

var mutex = new object();

// Низькопріоритетний потік захоплює mutex
var lowPriority = new Thread(() =>
{
    lock (mutex)   // ← захопив mutex!
    {
        Thread.Sleep(5000);  // виконує довгу роботу з mutex
    }
})
{ Priority = ThreadPriority.Lowest };

// Середньопріоритетний потік "витіснив" низький (той не встигає звільнити mutex)
var mediumPriority = new Thread(() =>
{
    while (true) { /* CPU-intensive робота — не відпускає планувальник */ }
})
{ Priority = ThreadPriority.Normal };

// Високопріоритетний потік чекає mutex який тримає Low, якого витісняє Medium
var highPriority = new Thread(() =>
{
    lock (mutex)  // ← ЧЕКАЄ! Low тримає mutex, Medium не дає Low виконатися
    {
        Console.WriteLine("High виконується (ніколи не відбудеться поки є Medium!)");
    }
})
{ Priority = ThreadPriority.Highest };

// РЕЗУЛЬТАТ: High (найбільший пріоритет) не може виконатися
// через Medium (нижчий пріоритет!) — Priority Inversion

var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
int lowExecutions = 0;
int highExecutions = 0;

// 4 High-priority потоки завжди готові виконуватись
for (int i = 0; i < Environment.ProcessorCount; i++)
{
    new Thread(() =>
    {
        while (!cts.Token.IsCancellationRequested)
            Interlocked.Increment(ref highExecutions);
    })
    { Priority = ThreadPriority.AboveNormal }.Start();
}

// Low-priority потік — може ніколи не виконатись (starvation)
var low = new Thread(() =>
{
    while (!cts.Token.IsCancellationRequested)
        Interlocked.Increment(ref lowExecutions);
})
{ Priority = ThreadPriority.Lowest };
low.Start();

Thread.Sleep(10_000);

Console.WriteLine($"High: {highExecutions:N0}");
Console.WriteLine($"Low:  {lowExecutions:N0}");
Console.WriteLine($"Low отримав {100.0 * lowExecutions / (highExecutions + lowExecutions):F4}% CPU часу");
// На завантаженій системі low може отримати < 0.01% CPU або взагалі нічого

using System.Threading;

// CancellationTokenSource — об'єкт управління скасуванням
using var cts = new CancellationTokenSource();
CancellationToken token = cts.Token;  // токен для передачі у потік

var worker = new Thread(() =>
{
    Console.WriteLine($"[{Thread.CurrentThread.Name}] Починаємо роботу");

    try
    {
        for (int i = 0; i < 100; i++)
        {
            // Варіант 1: Явна перевірка — гнучко, але вимагає ручних перевірок
            if (token.IsCancellationRequested)
            {
                Console.WriteLine($"[{Thread.CurrentThread.Name}] Скасування виявлено на ітерації {i}");
                break;
            }

            // Варіант 2: ThrowIfCancellationRequested — кидає OperationCanceledException
            // token.ThrowIfCancellationRequested();

            DoUnitOfWork(i);

            // Варіант 3: Sleep з підтримкою скасування
            // Thread.Sleep з CancellationToken — прокинеться при Cancel()
            token.WaitHandle.WaitOne(100);  // Sleep(100) з можливістю переривання
        }
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine($"[{Thread.CurrentThread.Name}] Коректно завершено через скасування");
    }
    finally
    {
        Console.WriteLine($"[{Thread.CurrentThread.Name}] Cleanup завершено");
        // Finally ЗАВЖДИ виконається — файли закриті, з'єднання закриті
    }
})
{ Name = "Worker" };

worker.Start();

// Через 2 секунди — скасовуємо
Thread.Sleep(2000);
cts.Cancel();      // встановлює IsCancellationRequested = true
worker.Join();     // чекаємо коректного завершення
Console.WriteLine("Потік завершився коректно");

void DoUnitOfWork(int iteration)
{
    // Якась осмислена робота
    Thread.Sleep(50);
}

using System.Threading;

// Ручне скасування
using var cts1 = new CancellationTokenSource();
cts1.Cancel();  // негайне скасування
// або
cts1.CancelAfter(TimeSpan.FromSeconds(5));  // відкладене скасування через 5s
cts1.CancelAfter(5000);                      // або у мілісекундах

// Скасування за таймаутом від початку
using var cts2 = new CancellationTokenSource(TimeSpan.FromSeconds(30));

// Ланцюгові токени: скасовується якщо будь-який з джерел скасовано
using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
    cts1.Token, cts2.Token
);

var token = linkedCts.Token;

// Підписка на скасування (викликається у ThreadPool, не у головному потоці)
token.Register(() =>
{
    Console.WriteLine("Скасування виявлено через Register callback!");
});

// Перевірка
Console.WriteLine($"IsCancellationRequested: {token.IsCancellationRequested}");

// ThrowIfCancellationRequested — стандартна перевірка у циклах
token.ThrowIfCancellationRequested();  // кидає OperationCanceledException

var thread = new Thread(() =>
{
    try
    {
        Console.WriteLine("Потік: чекаємо 60 секунд...");
        Thread.Sleep(60_000);  // або Monitor.Wait(), Join(), etc.
        Console.WriteLine("Потік: прокинулись нормально");
    }
    catch (ThreadInterruptedException)
    {
        // Кидається коли Interrupt() перериває WaitSleepJoin
        Console.WriteLine("Потік: перерваний через Interrupt()");
        // Можна зробити cleanup і завершити
    }
});

thread.Start();
Thread.Sleep(2000);

thread.Interrupt();  // перериває Thread.Sleep → кидає ThreadInterruptedException
thread.Join();

using System.Threading;

// ThreadLocal<T>: кожен потік отримує власну копію
// valueFactory: виклик для КОЖНОГО нового потоку окремо
using var localRandom = new ThreadLocal<Random>(
    valueFactory: () => new Random(Thread.CurrentThread.ManagedThreadId),
    trackAllValues: true  // дозволяє читати .Values (всі значення)
);

var threads = Enumerable.Range(0, 5).Select(i =>
{
    return new Thread(() =>
    {
        // localRandom.Value — ЦЯ копія для поточного потоку
        // Ніякої синхронізації не потрібно!
        int rng = localRandom.Value!.Next(1, 100);
        Console.WriteLine($"[Thread {Thread.CurrentThread.ManagedThreadId}] Random: {rng}");
        Thread.Sleep(rng);
    }) { Name = $"RngThread-{i}" };
}).ToList();

foreach (var t in threads) t.Start();
foreach (var t in threads) t.Join();

// Доступ до всіх значень (лише якщо trackAllValues: true)
// Console.WriteLine($"Ініціалізованих значень: {localRandom.Values.Count}");