using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 創(chuàng)建新線程
        Thread thread = new Thread(new ThreadStart(WorkerMethod));
        
        // 設(shè)置為后臺(tái)線程（可選）
        thread.IsBackground = true;
        
        // 啟動(dòng)線程
        thread.Start();
        
        // 主線程繼續(xù)執(zhí)行其他工作
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"主線程: {i}");
            Thread.Sleep(100);
        }
        
        // 等待工作線程完成（可選）
        thread.Join();
        Console.WriteLine("工作線程完成");
    }
    
    static void WorkerMethod()
    {
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine($"工作線程: {i}");
            Thread.Sleep(200);
        }
    }
}

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 將工作項(xiàng)排隊(duì)到線程池
        ThreadPool.QueueUserWorkItem(WorkerMethod, "參數(shù)1");
        ThreadPool.QueueUserWorkItem(WorkerMethod, "參數(shù)2");
        
        // 主線程繼續(xù)執(zhí)行其他工作
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"主線程: {i}");
            Thread.Sleep(100);
        }
        
        // 注意：ThreadPool沒有直接的等待機(jī)制
        Console.ReadLine(); // 防止程序退出
    }
    
    static void WorkerMethod(object state)
    {
        string param = (string)state;
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine($"{param}: {i}");
            Thread.Sleep(200);
        }
    }
}

using System;
using System.Threading.Tasks;

???????class Program
{
    static void Main()
    {
        // 創(chuàng)建并啟動(dòng)任務(wù)
        Task task1 = Task.Run(() => WorkerMethod("任務(wù)1"));
        Task task2 = Task.Run(() => WorkerMethod("任務(wù)2"));
        
        // 主線程繼續(xù)執(zhí)行其他工作
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"主線程: {i}");
            Task.Delay(100).Wait();
        }
        
        // 等待所有任務(wù)完成
        Task.WaitAll(task1, task2);
        Console.WriteLine("所有任務(wù)完成");
    }
    
    static void WorkerMethod(string taskName)
    {
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine($"{taskName}: {i}");
            Task.Delay(200).Wait();
        }
    }
}

using System;
using System.Threading.Tasks;

???????class Program
{
    static void Main()
    {
        // Parallel.For - 數(shù)據(jù)并行
        Parallel.For(0, 10, i => 
        {
            Console.WriteLine($"For迭代 {i}, 線程ID: {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(100);
        });
        
        // Parallel.ForEach - 數(shù)據(jù)并行
        var data = new[] { "A", "B", "C", "D", "E" };
        Parallel.ForEach(data, item => 
        {
            Console.WriteLine($"處理 {item}, 線程ID: {Thread.CurrentThread.ManagedThreadId}");
            Thread.Sleep(200);
        });
        
        // Parallel.Invoke - 任務(wù)并行
        Parallel.Invoke(
            () => WorkerMethod("任務(wù)1"),
            () => WorkerMethod("任務(wù)2"),
            () => WorkerMethod("任務(wù)3")
        );
    }
    
    static void WorkerMethod(string taskName)
    {
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine($"{taskName}: {i}");
            Thread.Sleep(200);
        }
    }
}

using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;

???????class Program
{
    static BackgroundWorker worker;
    
    static void Main()
    {
        worker = new BackgroundWorker();
        
        // 設(shè)置支持取消和進(jìn)度報(bào)告
        worker.WorkerReportsProgress = true;
        worker.WorkerSupportsCancellation = true;
        
        // 事件處理
        worker.DoWork += Worker_DoWork;
        worker.ProgressChanged += Worker_ProgressChanged;
        worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
        
        // 模擬UI線程
        Console.WriteLine("按S開始工作，C取消工作");
        while (true)
        {
            var key = Console.ReadKey(true);
            if (key.Key == ConsoleKey.S && !worker.IsBusy)
            {
                worker.RunWorkerAsync("參數(shù)");
                Console.WriteLine("工作已開始");
            }
            else if (key.Key == ConsoleKey.C && worker.IsBusy)
            {
                worker.CancelAsync();
                Console.WriteLine("取消請(qǐng)求已發(fā)送");
            }
        }
    }
    
    static void Worker_DoWork(object sender, DoWorkEventArgs e)
    {
        BackgroundWorker worker = (BackgroundWorker)sender;
        string param = (string)e.Argument;
        
        for (int i = 0; i <= 100; i++)
        {
            if (worker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            
            // 模擬工作
            Thread.Sleep(50);
            
            // 報(bào)告進(jìn)度
            worker.ReportProgress(i, $"處理 {param} - {i}%");
        }
        
        e.Result = $"完成 {param}";
    }
    
    static void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        Console.WriteLine($"進(jìn)度: {e.ProgressPercentage}%, 狀態(tài): {e.UserState}");
    }
    
    static void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        if (e.Cancelled)
        {
            Console.WriteLine("工作被取消");
        }
        else if (e.Error != null)
        {
            Console.WriteLine($"錯(cuò)誤: {e.Error.Message}");
        }
        else
        {
            Console.WriteLine($"結(jié)果: {e.Result}");
        }
    }
}

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("主線程開始");
        
        // 啟動(dòng)異步任務(wù)
        Task<string> task1 = DoWorkAsync("任務(wù)1");
        Task<string> task2 = DoWorkAsync("任務(wù)2");
        
        // 主線程可以繼續(xù)做其他工作
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine($"主線程工作 {i}");
            await Task.Delay(100);
        }
        
        // 等待任務(wù)完成并獲取結(jié)果
        string result1 = await task1;
        string result2 = await task2;
        
        Console.WriteLine($"結(jié)果1: {result1}");
        Console.WriteLine($"結(jié)果2: {result2}");
        Console.WriteLine("所有工作完成");
    }
    
    static async Task<string> DoWorkAsync(string name)
    {
        Console.WriteLine($"{name} 開始");
        
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"{name} 步驟 {i}");
            await Task.Delay(200); // 模擬異步工作
        }
        
        return $"{name} 完成";
    }
}

Thread workerThread = new Thread(WorkerMethod);
workerThread.Start();

// 主線程等待workerThread完成
workerThread.Join();
Console.WriteLine("工作線程已完成");

Task task1 = Task.Run(() => WorkerMethod("任務(wù)1"));
Task task2 = Task.Run(() => WorkerMethod("任務(wù)2"));

// 等待單個(gè)任務(wù)
task1.Wait();

// 等待所有任務(wù)
Task.WaitAll(task1, task2);

// 等待任意一個(gè)任務(wù)
Task.WaitAny(task1, task2);

async Task Main()
{
    Task task1 = DoWorkAsync("任務(wù)1");
    Task task2 = DoWorkAsync("任務(wù)2");
    
    // 異步等待
    await task1;
    await task2;
    
    // 或者同時(shí)等待多個(gè)任務(wù)
    await Task.WhenAll(task1, task2);
    // 或 await Task.WhenAny(task1, task2);
}

private static readonly object _lock = new object();

void CriticalSection()
{
    lock (_lock)
    {
        // 臨界區(qū)代碼
    }
}

using var mutex = new Mutex(false, "Global\\MyMutex");

try
{
    mutex.WaitOne();
    // 臨界區(qū)代碼
}
finally
{
    mutex.ReleaseMutex();
}

private static SemaphoreSlim _semaphore = new SemaphoreSlim(3); // 允許3個(gè)線程同時(shí)進(jìn)入

async Task AccessResource()
{
    await _semaphore.WaitAsync();
    try
    {
        // 受保護(hù)的代碼
    }
    finally
    {
        _semaphore.Release();
    }
}

private static ManualResetEvent _mre = new ManualResetEvent(false);

???????void Worker()
{
    Console.WriteLine("工作線程等待信號(hào)...");
    _mre.WaitOne();
    Console.WriteLine("工作線程收到信號(hào)");
}

void SetSignal()
{
    Thread.Sleep(2000);
    _mre.Set(); // 發(fā)送信號(hào)
}

Barrier barrier = new Barrier(3); // 3個(gè)參與者

void Worker(object name)
{
    Console.WriteLine($"{name} 到達(dá)階段1");
    barrier.SignalAndWait();
    
    Console.WriteLine($"{name} 到達(dá)階段2");
    barrier.SignalAndWait();
}

// 啟動(dòng)3個(gè)線程
new Thread(Worker).Start("線程1");
new Thread(Worker).Start("線程2");
new Thread(Worker).Start("線程3");

CountdownEvent cde = new CountdownEvent(3); // 初始計(jì)數(shù)3

void Worker(object name)
{
    Thread.Sleep(1000);
    Console.WriteLine($"{name} 完成工作");
    cde.Signal(); // 計(jì)數(shù)減1
}

// 啟動(dòng)3個(gè)線程
new Thread(Worker).Start("線程1");
new Thread(Worker).Start("線程2");
new Thread(Worker).Start("線程3");

???????cde.Wait(); // 等待計(jì)數(shù)歸零
Console.WriteLine("所有工作完成");

ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();

void ReadData()
{
    rwLock.EnterReadLock();
    try
    {
        // 讀取操作
    }
    finally
    {
        rwLock.ExitReadLock();
    }
}

???????void WriteData()
{
    rwLock.EnterWriteLock();
    try
    {
        // 寫入操作
    }
    finally
    {
        rwLock.ExitWriteLock();
    }
}

async Task ProcessAsync()
{
    Console.WriteLine("開始處理");
    await Task.Delay(1000); // 異步等待1秒
    Console.WriteLine("處理完成");
}

async Task ProcessMultipleAsync()
{
    Task task1 = DoWorkAsync("任務(wù)1");
    Task task2 = DoWorkAsync("任務(wù)2");
    Task task3 = DoWorkAsync("任務(wù)3");
    
    await Task.WhenAll(task1, task2, task3);
    Console.WriteLine("所有任務(wù)完成");
}

async Task ProcessFirstCompletedAsync()
{
    Task<int> task1 = DoWorkWithResultAsync("任務(wù)1", 2000);
    Task<int> task2 = DoWorkWithResultAsync("任務(wù)2", 1000);
    
    Task<int> completedTask = await Task.WhenAny(task1, task2);
    int result = await completedTask;
    Console.WriteLine($"第一個(gè)完成的任務(wù)結(jié)果: {result}");
}

async Task LongRunningOperationAsync(CancellationToken cancellationToken)
{
    for (int i = 0; i < 10; i++)
    {
        cancellationToken.ThrowIfCancellationRequested();
        
        Console.WriteLine($"工作進(jìn)度: {i * 10}%");
        await Task.Delay(500, cancellationToken);
    }
}

???????// 使用示例
var cts = new CancellationTokenSource();
try
{
    // 3秒后取消
    cts.CancelAfter(3000);
    await LongRunningOperationAsync(cts.Token);
}
catch (OperationCanceledException)
{
    Console.WriteLine("操作被取消");
}

Thread workerThread = new Thread(WorkerMethod);
workerThread.Start();

if (!workerThread.Join(TimeSpan.FromSeconds(3)))
{
    Console.WriteLine("工作線程未在3秒內(nèi)完成");
}

Task longRunningTask = Task.Run(() => Thread.Sleep(5000));

try
{
    if (!longRunningTask.Wait(TimeSpan.FromSeconds(3)))
    {
        Console.WriteLine("任務(wù)未在3秒內(nèi)完成");
    }
}
catch (AggregateException ae)
{
    // 處理異常
}

async Task ProcessWithTimeoutAsync()
{
    Task longTask = LongRunningOperationAsync();
    Task timeoutTask = Task.Delay(3000);
    
    Task completedTask = await Task.WhenAny(longTask, timeoutTask);
    if (completedTask == timeoutTask)
    {
        Console.WriteLine("操作超時(shí)");
        // 可能的取消邏輯
    }
    else
    {
        Console.WriteLine("操作按時(shí)完成");
    }
}

// 使用Monitor.TryEnter
if (Monitor.TryEnter(_lock, TimeSpan.FromSeconds(1)))
{
    try
    {
        // 臨界區(qū)代碼
    }
    finally
    {
        Monitor.Exit(_lock);
    }
}
else
{
    Console.WriteLine("獲取鎖超時(shí)");
}

???????// 使用SemaphoreSlim.WaitAsync
if (await _semaphore.WaitAsync(TimeSpan.FromSeconds(1)))
{
    try
    {
        // 受保護(hù)的代碼
    }
    finally
    {
        _semaphore.Release();
    }
}
else
{
    Console.WriteLine("獲取信號(hào)量超時(shí)");
}

var concurrentQueue = new ConcurrentQueue<int>();

// 多線程安全入隊(duì)
Parallel.For(0, 100, i => concurrentQueue.Enqueue(i));

// 多線程安全出隊(duì)
Parallel.For(0, 100, i => 
{
    if (concurrentQueue.TryDequeue(out int item))
    {
        Console.WriteLine($"出隊(duì): {item}");
    }
});

if (Monitor.TryEnter(_lock, TimeSpan.FromSeconds(1)))
{
    try { /* 臨界區(qū) */ }
    finally { Monitor.Exit(_lock); }
}

// 死鎖示例
object lock1 = new object();
object lock2 = new object();

void Thread1()
{
    lock (lock1)
    {
        Thread.Sleep(100);
        lock (lock2) { /* ... */ }
    }
}

void Thread2()
{
    lock (lock2)
    {
        Thread.Sleep(100);
        lock (lock1) { /* ... */ }
    }
}

// 解決方案：固定鎖順序
void SafeThread1()
{
    lock (lock1)
    {
        Thread.Sleep(100);
        lock (lock2) { /* ... */ }
    }
}

???????void SafeThread2()
{
    lock (lock1) // 與Thread1相同的順序
    {
        Thread.Sleep(100);
        lock (lock2) { /* ... */ }
    }
}

var sw = Stopwatch.StartNew();
// 被測(cè)代碼
sw.Stop();
Console.WriteLine($"耗時(shí): {sw.ElapsedMilliseconds}ms");

Thread worker = new Thread(WorkerMethod);
worker.Name = "Worker Thread";

Debug.WriteLine($"線程 {Thread.CurrentThread.Name} 進(jìn)入方法X");

public class AsyncLogger : IDisposable
{
    private readonly BlockingCollection<string> _logQueue = new BlockingCollection<string>(10000);
    private readonly Task _processingTask;
    private readonly StreamWriter _writer;
    private readonly CancellationTokenSource _cts = new CancellationTokenSource();

    public AsyncLogger(string filePath)
    {
        _writer = new StreamWriter(filePath, append: true);
        _processingTask = Task.Run(ProcessLogs);
    }

    public void Log(string message)
    {
        if (!_logQueue.TryAdd($"{DateTime.UtcNow:o}: {message}"))
        {
            // 隊(duì)列已滿，可選擇丟棄或等待
            _logQueue.Add(message); // 阻塞直到有空間
        }
    }

    private async Task ProcessLogs()
    {
        try
        {
            foreach (var message in _logQueue.GetConsumingEnumerable(_cts.Token))
            {
                try
                {
                    await _writer.WriteLineAsync(message);
                    
                    // 定期刷新以提高性能
                    if (_logQueue.Count == 0)
                    {
                        await _writer.FlushAsync();
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"日志寫入失敗: {ex.Message}");
                }
            }
        }
        catch (OperationCanceledException)
        {
            // 正常退出
        }
        
        // 最終刷新
        await _writer.FlushAsync();
    }

    public void Dispose()
    {
        _logQueue.CompleteAdding();
        _cts.Cancel();
        _processingTask.Wait();
        _writer.Dispose();
        _cts.Dispose();
    }
}

// 使用示例
using var logger = new AsyncLogger("app.log");

// 多線程記錄日志
Parallel.For(0, 100, i => 
{
    logger.Log($"消息 {i} 來自線程 {Thread.CurrentThread.ManagedThreadId}");
});

public class DataProcessingPipeline
{
    public async Task ProcessDataAsync(IEnumerable<InputData> inputData)
    {
        // 階段1: 并行數(shù)據(jù)加載和初步處理
        var stage1Results = inputData
            .AsParallel()
            .WithDegreeOfParallelism(Environment.ProcessorCount)
            .Select(LoadAndPreprocessData)
            .ToList();
            
        // 階段2: 并行復(fù)雜計(jì)算
        var stage2Tasks = stage1Results
            .Select(data => Task.Run(() => ComputeComplexFeatures(data)))
            .ToArray();
            
        var stage2Results = await Task.WhenAll(stage2Tasks);
        
        // 階段3: 并行驗(yàn)證和過濾
        var stage3Results = new ConcurrentBag<ResultData>();
        Parallel.ForEach(stage2Results, data =>
        {
            if (ValidateData(data))
            {
                var transformed = TransformData(data);
                stage3Results.Add(transformed);
            }
        });
        
        // 階段4: 批量存儲(chǔ)
        await BatchStoreResultsAsync(stage3Results);
    }
    
    private InputData LoadAndPreprocessData(RawData raw)
    {
        // 模擬耗時(shí)操作
        Thread.Sleep(10);
        return new InputData();
    }
    
    private ComplexData ComputeComplexFeatures(InputData input)
    {
        // 模擬CPU密集型操作
        Thread.Sleep(100);
        return new ComplexData();
    }
    
    private bool ValidateData(ComplexData data)
    {
        // 簡(jiǎn)單驗(yàn)證
        return true;
    }
    
    private ResultData TransformData(ComplexData data)
    {
        return new ResultData();
    }
    
    private async Task BatchStoreResultsAsync(IEnumerable<ResultData> results)
    {
        // 模擬批量存儲(chǔ)
        await Task.Delay(100);
    }
}

public class DashboardViewModel : INotifyPropertyChanged
{
    private readonly CancellationTokenSource _cts = new CancellationTokenSource();
    private readonly ObservableCollection<DataItem> _items = new ObservableCollection<DataItem>();
    private readonly object _syncLock = new object();
    private double _averageValue;
    
    public event PropertyChangedEventHandler PropertyChanged;
    
    public ObservableCollection<DataItem> Items => _items;
    
    public double AverageValue
    {
        get => _averageValue;
        private set
        {
            if (_averageValue != value)
            {
                _averageValue = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(AverageValue)));
            }
        }
    }
    
    public DashboardViewModel()
    {
        // 啟動(dòng)數(shù)據(jù)收集任務(wù)
        Task.Run(() => CollectDataAsync(_cts.Token));
    }
    
    private async Task CollectDataAsync(CancellationToken ct)
    {
        var dataSources = new IDataSource[]
        {
            new NetworkDataSource(),
            new FileDataSource(),
            new DatabaseDataSource()
        };
        
        while (!ct.IsCancellationRequested)
        {
            try
            {
                // 并行從所有數(shù)據(jù)源獲取數(shù)據(jù)
                var tasks = dataSources
                    .Select(ds => ds.GetDataAsync(ct))
                    .ToArray();
                
                // 等待所有數(shù)據(jù)源響應(yīng)或超時(shí)
                var timeoutTask = Task.Delay(TimeSpan.FromSeconds(5), ct);
                var completedTask = await Task.WhenAny(
                    Task.WhenAll(tasks),
                    timeoutTask);
                
                if (completedTask == timeoutTask)
                {
                    Debug.WriteLine("數(shù)據(jù)獲取超時(shí)");
                    continue;
                }
                
                // 處理接收到的數(shù)據(jù)
                var allData = tasks.Select(t => t.Result).ToList();
                var newItems = ProcessData(allData);
                
                // 更新UI線程上的集合
                await Application.Current.Dispatcher.InvokeAsync(() =>
                {
                    foreach (var item in newItems)
                    {
                        _items.Add(item);
                    }
                    
                    // 保持合理數(shù)量的項(xiàng)目
                    while (_items.Count > 1000)
                    {
                        _items.RemoveAt(0);
                    }
                    
                    // 更新平均值
                    AverageValue = _items.Average(i => i.Value);
                }, System.Windows.Threading.DispatcherPriority.Background);
                
                // 短暫延遲
                await Task.Delay(TimeSpan.FromSeconds(1), ct);
            }
            catch (OperationCanceledException)
            {
                // 正常退出
                break;
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"數(shù)據(jù)收集錯(cuò)誤: {ex.Message}");
                await Task.Delay(TimeSpan.FromSeconds(5), ct);
            }
        }
    }
    
    private List<DataItem> ProcessData(List<RawData[]> allData)
    {
        // 模擬數(shù)據(jù)處理
        var result = new List<DataItem>();
        foreach (var dataSet in allData)
        {
            foreach (var raw in dataSet)
            {
                result.Add(new DataItem
                {
                    Timestamp = DateTime.Now,
                    Value = raw.Value * 1.2,
                    Source = raw.SourceName
                });
            }
        }
        return result;
    }
    
    public void Dispose()
    {
        _cts.Cancel();
        _cts.Dispose();
    }
}