c# 的多线程实现

我用ai给写的例子

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Concurrent;

// 使用 Lazy<T> 实现单例模式
public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazy =
        new Lazy<Singleton>(() => new Singleton());

    public static Singleton Instance { get { return lazy.Value; } }

    private Singleton()
    {
        // 私有构造函数，防止外部实例化
    }

    public void DoSomething()
    {
        Console.WriteLine("单例实例执行操作");
    }
}

class Program
{
    static int sharedValue = 0;

    static void Main()
    {
        // Parallel.For 示例
        Console.WriteLine("Parallel.For 示例:");
        Parallel.For(0, 10, i =>
        {
            Console.WriteLine($"当前线程 ID: {System.Threading.Thread.CurrentThread.ManagedThreadId}, 迭代值: {i}");
        });

        // Parallel.ForEach 示例
        Console.WriteLine("\nParallel.ForEach 示例:");
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        Parallel.ForEach(numbers, num =>
        {
            Console.WriteLine($"当前线程 ID: {System.Threading.Thread.CurrentThread.ManagedThreadId}, 元素值: {num}");
        });

        // Parallel.Invoke 示例
        Console.WriteLine("\nParallel.Invoke 示例:");
        Parallel.Invoke(
            () => Console.WriteLine($"操作 1 在线程 {System.Threading.Thread.CurrentThread.ManagedThreadId} 上执行"),
            () => Console.WriteLine($"操作 2 在线程 {System.Threading.Thread.CurrentThread.ManagedThreadId} 上执行"),
            () => Console.WriteLine($"操作 3 在线程 {System.Threading.Thread.CurrentThread.ManagedThreadId} 上执行")
        );

        // 优化后的 PLINQ 示例
        Console.WriteLine("\n优化后的 PLINQ 示例:");
        int[] plinqNumbers = Enumerable.Range(1, 1000).ToArray();
        // 获取系统处理器核心数
        int coreCount = Environment.ProcessorCount; 
        var optimizedPlinqResult = plinqNumbers.AsParallel()
                                               .WithDegreeOfParallelism(coreCount)
                                               // 过滤不必要的数据
                                               .Where(n => n % 2 == 0) 
                                               // 合并操作
                                               .Select(n => n * 2); 

        foreach (var result in optimizedPlinqResult)
        {
            Console.WriteLine(result);
        }

        // Interlocked 示例
        Console.WriteLine("\nInterlocked 示例:");
        Task[] tasks = new Task[10];
        for (int i = 0; i < 10; i++)
        {
            tasks[i] = Task.Run(() =>
            {
                for (int j = 0; j < 1000; j++)
                {
                    Interlocked.Add(ref sharedValue, 1);
                }
            });
        }

        Task.WaitAll(tasks);
        Console.WriteLine($"Interlocked 操作后的最终结果: {sharedValue}");

        // 单例模式示例
        Console.WriteLine("\n单例模式示例:");
        Singleton singletonInstance = Singleton.Instance;
        singletonInstance.DoSomething();

        // ConcurrentBag 示例
        Console.WriteLine("\nConcurrentBag 示例:");
        ConcurrentBag<int> concurrentBag = new ConcurrentBag<int>();
        Task[] bagTasks = new Task[10];
        for (int i = 0; i < 10; i++)
        {
            int index = i;
            bagTasks[i] = Task.Run(() =>
            {
                concurrentBag.Add(index);
                Console.WriteLine($"向 ConcurrentBag 添加元素: {index}");
            });
        }
        Task.WaitAll(bagTasks);

        foreach (var item in concurrentBag)
        {
            Console.WriteLine($"从 ConcurrentBag 中获取元素: {item}");
        }

        // ConcurrentStack 示例
        Console.WriteLine("\nConcurrentStack 示例:");
        ConcurrentStack<int> concurrentStack = new ConcurrentStack<int>();
        Task[] stackTasks = new Task[10];
        for (int i = 0; i < 10; i++)
        {
            int index = i;
            stackTasks[i] = Task.Run(() =>
            {
                concurrentStack.Push(index);
                Console.WriteLine($"向 ConcurrentStack 推入元素: {index}");
            });
        }
        Task.WaitAll(stackTasks);

        int result;
        while (concurrentStack.TryPop(out result))
        {
            Console.WriteLine($"从 ConcurrentStack 弹出元素: {result}");
        }

        // ConcurrentQueue 示例
        Console.WriteLine("\nConcurrentQueue 示例:");
        ConcurrentQueue<int> concurrentQueue = new ConcurrentQueue<int>();
        Task[] queueTasks = new Task[10];
        for (int i = 0; i < 10; i++)
        {
            int index = i;
            queueTasks[i] = Task.Run(() =>
            {
                concurrentQueue.Enqueue(index);
                Console.WriteLine($"向 ConcurrentQueue 入队元素: {index}");
            });
        }
        Task.WaitAll(queueTasks);

        while (concurrentQueue.TryDequeue(out int queueResult))
        {
            Console.WriteLine($"从 ConcurrentQueue 出队元素: {queueResult}");
        }

        // ConcurrentDictionary 示例
        Console.WriteLine("\nConcurrentDictionary 示例:");
        ConcurrentDictionary<int, string> concurrentDictionary = new ConcurrentDictionary<int, string>();
        Task[] dictTasks = new Task[10];
        for (int i = 0; i < 10; i++)
        {
            int index = i;
            dictTasks[i] = Task.Run(() =>
            {
                concurrentDictionary.TryAdd(index, $"Value {index}");
                Console.WriteLine($"向 ConcurrentDictionary 添加键值对: {index} - Value {index}");
            });
        }
        Task.WaitAll(dictTasks);

        foreach (var kvp in concurrentDictionary)
        {
            Console.WriteLine($"从 ConcurrentDictionary 获取键值对: {kvp.Key} - {kvp.Value}");
        }

        // SemaphoreSlim 示例
        Console.WriteLine("\nSemaphoreSlim 示例:");
        // 初始计数为 2，最大计数为 2，表示最多允许 2 个线程同时访问
        SemaphoreSlim semaphore = new SemaphoreSlim(2, 2);
        Task[] semaphoreTasks = new Task[5];
        for (int i = 0; i < 5; i++)
        {
            int index = i;
            semaphoreTasks[i] = Task.Run(async () =>
            {
                Console.WriteLine($"任务 {index} 等待进入信号量...");
                await semaphore.WaitAsync();
                try
                {
                    Console.WriteLine($"任务 {index} 已进入信号量，正在执行...");
                    await Task.Delay(1000);
                }
                finally
                {
                    Console.WriteLine($"任务 {index} 离开信号量。");
                    semaphore.Release();
                }
            });
        }
        Task.WaitAll(semaphoreTasks);

        // ManualResetEventSlim 示例
        Console.WriteLine("\nManualResetEventSlim 示例:");
        ManualResetEventSlim manualEvent = new ManualResetEventSlim(false);
        Task.Run(() =>
        {
            Console.WriteLine("工作线程开始工作...");
            Thread.Sleep(2000);
            Console.WriteLine("工作线程工作完成，设置事件为有信号状态。");
            manualEvent.Set();
        });

        Console.WriteLine("主线程等待工作线程完成...");
        manualEvent.Wait();
        Console.WriteLine("主线程继续执行。");

        // ReaderWriterLockSlim 示例
        Console.WriteLine("\nReaderWriterLockSlim 示例:");
        ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
        List<int> data = new List<int> { 1, 2, 3, 4, 5 };

        // 读操作任务
        Task[] readerTasks = new Task[3];
        for (int i = 0; i < 3; i++)
        {
            int index = i;
            readerTasks[i] = Task.Run(() =>
            {
                rwLock.EnterReadLock();
                try
                {
                    Console.WriteLine($"读者 {index} 开始读取数据: {string.Join(", ", data)}");
                    Thread.Sleep(1000);
                }
                finally
                {
                    rwLock.ExitReadLock();
                    Console.WriteLine($"读者 {index} 读取完成。");
                }
            });
        }

        // 写操作任务
        Task writerTask = Task.Run(() =>
        {
            rwLock.EnterWriteLock();
            try
            {
                Console.WriteLine("写者开始写入数据...");
                data.Add(6);
                Thread.Sleep(1500);
            }
            finally
            {
                rwLock.ExitWriteLock();
                Console.WriteLine("写者写入完成。");
            }
        });

        Task.WaitAll(readerTasks.Concat(new[] { writerTask }).ToArray());
    }
}    

 

 

对应的文档：

Threading 相关视频的资源分享 · BYJRK/DotNet-Discussions · Discussion #148 · GitHub

C#多线程入门概念及技巧_哔哩哔哩_bilibili