/// <summary>
        /// 獲取自增
        /// </summary>
        public static void GetIncrement()
        {
            long result = 0;
            Console.WriteLine("開(kāi)始計(jì)算");
            //10個(gè)并發(fā)執(zhí)行
            Parallel.For(0, 10, (i) =>
            {
                    for (int j = 0; j < 10000; j++)
                    {
                        result++;
                    }
            });
            Console.WriteLine("結(jié)束計(jì)算");
            Console.WriteLine($"result正確值應(yīng)為：{10000 * 10}");
            Console.WriteLine($"result    現(xiàn)值為：{result}");
            Console.ReadLine();
        }

private static Object _obj = new object();
　　　　　/// <summary>
        /// 原子操作基于Lock實(shí)現(xiàn)
        /// </summary>
        public static void AtomicityForLock()
        {
            long result = 0;
            Console.WriteLine("開(kāi)始計(jì)算");
            //10個(gè)并發(fā)執(zhí)行
           Parallel.For(0, 10, (i) =>
            {
                //lock鎖
                lock (_obj)
                {
                    for (int j = 0; j < 10000; j++)
                    {
                        result++;
                    }
                }
            });
            Console.WriteLine("結(jié)束計(jì)算");
            Console.WriteLine($"result正確值應(yīng)為：{10000 * 10}");
            Console.WriteLine($"result    現(xiàn)值為：{result}");
            Console.ReadLine();

        }

/// <summary>
        /// 自增CAS實(shí)現(xiàn)
        /// </summary>
        public static void AtomicityForInterLock()
        {
            long result = 0;
            Console.WriteLine("開(kāi)始計(jì)算");
           Parallel.For(0, 10, (i) =>
            {
                for (int j = 0; j < 10000; j++)
                {
                    //自增
                    Interlocked.Increment(ref result);
                }
            });
            Console.WriteLine($"結(jié)束計(jì)算");
            Console.WriteLine($"result正確值應(yīng)為：{10000 * 10}");
            Console.WriteLine($"result    現(xiàn)值為：{result}");
            Console.ReadLine();
        }

/// <summary>
        /// 基于CAS原子操作自己寫(xiě)
        /// </summary>
        public static void AtomicityForMyCalc()
        {
            long result = 0;
            Console.WriteLine("開(kāi)始計(jì)算");
          
            Parallel.For(0, 10, (i) =>
            {
                long init = 0;
                long incrementNum = 0;
                for (int j = 0; j < 10000; j++)
                {
                    do
                    {
                        init = result;
                        incrementNum = result + 1;
                        incrementNum= incrementNum > 10000 ? 1 : incrementNum; //自增到10000后初始化成1

                    }
                    //如果result=init,則result的值被incrementNum替換,否則result不變,返回的是result的原始值
                    while (init != Interlocked.CompareExchange(ref result, incrementNum, init));
                    if(incrementNum==10000)
                    {
                        Console.WriteLine($"自增到達(dá)10000啦!值被初始化為1");
                    }
                }
            });
            Console.WriteLine($"結(jié)束計(jì)算");

            Console.WriteLine($"result正確值應(yīng)為：{10000}");
            Console.WriteLine($"result    現(xiàn)值為：{result}");
            Console.ReadLine();

        }

//創(chuàng)建自旋鎖
        private static SpinLock spin = new SpinLock();
        public static void Spinklock()
        {
            Action action = () =>
            {
                bool lockTaken = false;
                try
                {
                    //申請(qǐng)獲取鎖
                    spin.Enter(ref lockTaken);
                    //臨界區(qū)
                    for (int i = 0; i < 10; i++)
                    {
                        Console.WriteLine($"當(dāng)前線程{Thread.CurrentThread.ManagedThreadId.ToString()},輸出:1");
                    }
                }
                finally
                {
                    //工作完畢，或者產(chǎn)生異常時(shí)，檢測(cè)一下當(dāng)前線程是否占有鎖，如果有了鎖釋放它
                    //避免出行死鎖
                    if(lockTaken)
                    {
                        spin.Exit();
                    }
                }
            };
            Action action2 = () =>
            {
                bool lockTaken = false;
                try
                {
                    //申請(qǐng)獲取鎖
                    spin.Enter(ref lockTaken);
                    //臨界區(qū)
                    for (int i = 0; i < 10; i++)
                    {
                        Console.WriteLine($"當(dāng)前線程{Thread.CurrentThread.ManagedThreadId.ToString()},輸出:2");
                    }

                }
                finally
                {
                    //工作完畢，或者產(chǎn)生異常時(shí)，檢測(cè)一下當(dāng)前線程是否占有鎖，如果有了鎖釋放它
                    //避免出行死鎖
                    if (lockTaken)
                    {
                        spin.Exit();
                    }
                }

            };
            //并行執(zhí)行2個(gè)action
            Parallel.Invoke(action, action2);
            
        }

//讀寫(xiě)鎖， //策略支持遞歸
        private static ReaderWriterLockSlim rwl = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
        private static int index = 0;
        static void read()
        {
            try
            {
                //進(jìn)入讀鎖
                rwl.EnterReadLock();
                for (int i = 0; i < 5; i++)
                {
                    Console.WriteLine($"線程id:{Thread.CurrentThread.ManagedThreadId},讀數(shù)據(jù),讀到index:{index}");
                }
            }
            finally
            {
                //退出讀鎖
                rwl.ExitReadLock();
            }
        }
        static void write()
        {
            try
            {
                //嘗試獲寫(xiě)鎖
                while (!rwl.TryEnterWriteLock(50))
                {
                    Console.WriteLine($"線程id:{Thread.CurrentThread.ManagedThreadId},等待寫(xiě)鎖");
                }
                Console.WriteLine($"線程id:{Thread.CurrentThread.ManagedThreadId},獲取到寫(xiě)鎖");
                for (int i = 0; i < 5; i++)
                {
                    index++;
                    Thread.Sleep(50);
                }
                Console.WriteLine($"線程id:{Thread.CurrentThread.ManagedThreadId},寫(xiě)操作完成");
            }
            finally
            {
                //退出寫(xiě)鎖
                rwl.ExitWriteLock();
            }
        }

        /// <summary>
        /// 執(zhí)行多線程讀寫(xiě)
        /// </summary>
        public static void test()
        {
            var taskFactory = new TaskFactory(TaskCreationOptions.LongRunning, TaskContinuationOptions.None);
            Task[] task = new Task[6];
            task[1] = taskFactory.StartNew(write); //寫(xiě)
            task[0] = taskFactory.StartNew(read); //讀
            task[2] = taskFactory.StartNew(read); //讀
            task[3] = taskFactory.StartNew(write); //寫(xiě)
            task[4] = taskFactory.StartNew(read); //讀
            task[5] = taskFactory.StartNew(read); //讀

            for (var i=0; i<6; i++)
            {
                task[i].Wait();
            }

        }

/// <summary>
        /// 線程安全集合用法
        /// </summary>
        public static void BC()
        {
            //線程安全集合
            using (BlockingCollection<int> blocking = new BlockingCollection<int>())
            {
                int NUMITEMS = 10000;

                for (int i = 1; i < NUMITEMS; i++)
                {
                    blocking.Add(i);
                }
                //完成添加
                blocking.CompleteAdding();

                int outerSum = 0;

                // 定義一個(gè)委托方法取出集合元素
                Action action = () =>
                {
                    int localItem;
                    int localSum = 0;

                    //取出并刪除元素，先進(jìn)先出
                    while (blocking.TryTake(out localItem))
                    {
                        localSum += localItem;
                    }
                    //兩數(shù)相加替換第一個(gè)值
                    Interlocked.Add(ref outerSum, localSum);
                };

                //并行3個(gè)線程執(zhí)行，多個(gè)線程同時(shí)取集合的數(shù)據(jù)
                Parallel.Invoke(action, action, action);

                Console.WriteLine($"0+...{NUMITEMS-1} = {((NUMITEMS * (NUMITEMS - 1)) / 2)},輸出結(jié)果：{outerSum}");
                //此集合是否已標(biāo)記為已完成添加且為空
                Console.WriteLine($"線程安全集合.IsCompleted={blocking.IsCompleted}");
            }
        }

/// <summary>
        /// 限制集合長(zhǎng)度
        /// </summary>
        public static void BCLimtLength()
        {
            //限制集合長(zhǎng)度為5個(gè)，后面進(jìn)的會(huì)阻塞等集合少于5個(gè)再進(jìn)來(lái)
            BlockingCollection<int> blocking = new BlockingCollection<int>(5);

            var task1= Task.Run(() =>
            {
                for (int i = 0; i < 20; i++)
                {
                    blocking.Add(i);
                    Console.WriteLine($"集合添加:({i})");
                }

                blocking.CompleteAdding();
                Console.WriteLine("完成添加");
            });

            // 延遲500ms執(zhí)行等待先生產(chǎn)數(shù)據(jù)
            var task2 = Task.Delay(500).ContinueWith((t) =>
            {
                while (!blocking.IsCompleted)
                {
                    var n = 0;
                    if (blocking.TryTake(out n))
                    {
                        Console.WriteLine($"取出:({n})");
                    }
                }

                Console.WriteLine("IsCompleted = true");
            });

            Task.WaitAll(task1, task2);
        }

/// <summary>
        /// 線程安全集合，先進(jìn)后出
        /// </summary>
        public static void BCStack()
        {
            //線程安全集合，參數(shù)表明棧標(biāo)識(shí)，隊(duì)列長(zhǎng)度為5
            BlockingCollection<int> blocking = new BlockingCollection<int>(new ConcurrentStack<int>(), 5);

            var task1 = Task.Run(() =>
            {
                for (int i = 0; i < 20; i++)
                {
                    blocking.Add(i);
                    Console.WriteLine($"集合添加:({i})");
                }

                blocking.CompleteAdding();
                Console.WriteLine("完成添加");
            });

            // 等待先生產(chǎn)數(shù)據(jù)
            var task2 = Task.Delay(500).ContinueWith((t) =>
            {
                while (!blocking.IsCompleted)
                {
                    var n = 0;
                    if (blocking.TryTake(out n))
                    {
                        Console.WriteLine($"取出:({n})");
                    }
                }

                Console.WriteLine("IsCompleted = true");
            });

            Task.WaitAll(task1, task2);
        }

//普通字典
        private static IDictionary<string, string> Dictionaries { get; set; } = new Dictionary<string, string>();
    　　/// <summary>
        /// 字典增加值
        /// </summary>
       public static void AddDictionaries()
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            //并發(fā)1000個(gè)線程寫(xiě)
            Parallel.For(0, 1000, (i) =>
            {
                var key = $"key-{i}";
                var value = $"value-{i}";

                // 不加鎖會(huì)報(bào)錯(cuò)
               // lock (Dictionaries)
               // {
                    Dictionaries.Add(key, value);
               // }
            });
            sw.Stop();
            Console.WriteLine("Dictionaries 當(dāng)前數(shù)據(jù)量為： {0}", Dictionaries.Count);
            Console.WriteLine("Dictionaries 執(zhí)行時(shí)間為： {0} ms", sw.ElapsedMilliseconds);
        }

//線程安全字典
        private static IDictionary<string, string> ConcurrentDictionaries { get; set; } = new ConcurrentDictionary<string, string>();

　　　　　　/// <summary>
        /// 線程安全字典添加值
        /// </summary>
        public static void AddConcurrentDictionaries()
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            //并發(fā)1000個(gè)線程寫(xiě)
            Parallel.For(0, 1000, (i) =>
            {
                var key = $"key-{i}";
                var value = $"value-{i}";

                // 無(wú)須加鎖
                ConcurrentDictionaries.Add(key, value);
                
            });
            sw.Stop();
            Console.WriteLine("ConcurrentDictionaries 當(dāng)前數(shù)據(jù)量為： {0}", ConcurrentDictionaries.Count);
            Console.WriteLine("ConcurrentDictionaries 執(zhí)行時(shí)間為： {0} ms", sw.ElapsedMilliseconds);
        }

public class ThreadLoopDemo
    {

        /// <summary>
        /// 回調(diào)方法
        /// </summary>
        /// <param name="obj"></param>
        static void CallMethod(object state)
        {
            Console.WriteLine("RunWorkerThread開(kāi)始工作");
            Console.WriteLine("工作者線程啟動(dòng)成功!");
        }

        public static void Test()
        {
       　　 //工作者線程最大數(shù)目，I/O線程的最大數(shù)目
      　　　　  ThreadPool.SetMaxThreads(1000, 1000);
            //啟動(dòng)工作者線程
            ThreadPool.QueueUserWorkItem(new WaitCallback(CallMethod!));
            Console.ReadKey();
        }
    }

public class ThreadLoopDemo
    {
        /// <summary>
        /// 回調(diào)方法
        /// </summary>
        /// <param name="obj"></param>
        static void CallMethod(object state)
        {
            Console.WriteLine("RunWorkerThread開(kāi)始工作");
            Order order=state as Order;
            Console.WriteLine($"orderName:{order.orderName},price:{order.price}");
            Console.WriteLine("工作者線程啟動(dòng)成功!");
        }

        public static void Test()
        {
            //工作者線程最大數(shù)目，I/O線程的最大數(shù)目
            ThreadPool.SetMaxThreads(1000, 1000);
            Order order = new Order()
            {
                orderName = "冰箱",
                price = 1888
            };
            //啟動(dòng)工作者線程
            ThreadPool.QueueUserWorkItem(new WaitCallback(CallMethod!),order);
            Console.ReadKey();
        }

    }
    public class Order
    {
        public string orderName { get; set; }
        public decimal price { get; set; }
    }

public class ThreadLoopDemo
    {
        /// <summary>
        /// 執(zhí)行
        /// </summary>
        public static void Test()
        {
            //用來(lái)控制線程等待,false默認(rèn)為關(guān)閉狀態(tài)
            ManualResetEvent mre = new ManualResetEvent(false);
            ThreadPool.QueueUserWorkItem(p =>
            {

                Console.WriteLine("線程1開(kāi)始");
                Thread.Sleep(1000);
                Console.WriteLine($"線程1結(jié)束，帶參數(shù),{Thread.CurrentThread.ManagedThreadId}");
                //通知線程，修改信號(hào)為true
                mre.Set();
            });

            //阻止當(dāng)前線程，直到等到信號(hào)為true在繼續(xù)執(zhí)行
            mre.WaitOne();

            //關(guān)閉線程，相當(dāng)于設(shè)置成false
            mre.Reset();
            Console.WriteLine("信號(hào)被關(guān)閉了");

            ThreadPool.QueueUserWorkItem(p =>
            {
                Console.WriteLine("線程2開(kāi)始");
                Thread.Sleep(2000);
                Console.WriteLine("線程2結(jié)束");
                mre.Set();
              
            });

            mre.WaitOne();
            Console.WriteLine("主線程結(jié)束");

        }
    }

public class TaskDemo
    {
        /// <summary>
        /// 一個(gè)比較耗時(shí)的方法,循環(huán)1000W次
        /// </summary>
        /// <param name="name"></param>
        public static void DoSomething(string name)
        {
            int iResult = 0;
            for (int i = 0; i < 1000000000; i++)
            {
                iResult += i;
            }

            Console.WriteLine($"{name},線程Id:{Thread.CurrentThread.ManagedThreadId},{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")}"+Environment.NewLine);
        }

        public static void Test()
        {
            //線程容器
            List<Task> taskList = new List<Task>();
            Stopwatch watch = new Stopwatch();
            watch.Start();
            Console.WriteLine("************任務(wù)開(kāi)始**************");

            //啟動(dòng)5個(gè)線程
            for (int i = 0; i < 5; i++)
            {
                string name = $"Task:{i}";
                Task task = Task.Factory.StartNew(() =>
                {
                    DoSomething(name);
                });

                taskList.Add(task);
            }

            //回調(diào)形式的，任意一個(gè)完成后執(zhí)行的后續(xù)動(dòng)作
            Task any = Task.Factory.ContinueWhenAny(taskList.ToArray(), task =>
            {
                Console.WriteLine($"ContinueWhenAny,當(dāng)前線程Id:{Thread.CurrentThread.ManagedThreadId},一個(gè)線程執(zhí)行完的回調(diào)，繼續(xù)執(zhí)行后面動(dòng)作，{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")}" + Environment.NewLine);
            });

            //回調(diào)形式的，全部任務(wù)完成后執(zhí)行的后續(xù)動(dòng)作
            Task all = Task.Factory.ContinueWhenAll(taskList.ToArray(), tasks =>
            {
                Console.WriteLine($"ContinueWhenAll,當(dāng)前線程Id:{Thread.CurrentThread.ManagedThreadId},全部線程執(zhí)行完的回調(diào),線程數(shù)：{tasks.Length},{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")}" + Environment.NewLine);
            });

            //把兩個(gè)回調(diào)也放到容器里面，包含回調(diào)一起等待
            taskList.Add(any);
            taskList.Add(all);

            //WaitAny:線程等待，當(dāng)前線程等待其中一個(gè)線程完成
            Task.WaitAny(taskList.ToArray());
            Console.WriteLine($"WaitAny,當(dāng)前線程Id:{Thread.CurrentThread.ManagedThreadId},其中一個(gè)完成已完成,{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")}" + Environment.NewLine);

            //WaitAll:線程等待，當(dāng)前線程等待所有線程的完成
            Task.WaitAll(taskList.ToArray());
            Console.WriteLine($"WaitAll，當(dāng)前線程Id:{Thread.CurrentThread.ManagedThreadId},全部線程完成，{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")}" + Environment.NewLine);

            Console.WriteLine($"************任務(wù)結(jié)束**************耗時(shí)：{watch.ElapsedMilliseconds}ms,{Thread.CurrentThread.ManagedThreadId},{DateTime.Now}");
        }
    }

/// <summary>
        /// 一個(gè)比較耗時(shí)的方法,循環(huán)1000W次
        /// </summary>
        /// <param name="name"></param>
        public static void DoSomething(string name)
        {
            int iResult = 0;
            for (int i = 0; i < 1000000000; i++)
            {
                iResult += i;
            }

            Console.WriteLine($"{name},線程Id:{Thread.CurrentThread.ManagedThreadId},{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")}" + Environment.NewLine);
        }


        public static void Test1()
        {
            //并行編程 
            Console.WriteLine($"并行編程開(kāi)始，主線程Id:{Thread.CurrentThread.ManagedThreadId}");
            Console.WriteLine("【示例1】");
            //示例1：
            //一次性執(zhí)行1個(gè)或多個(gè)線程，效果類(lèi)似：Task WaitAll，只不過(guò)Parallel的主線程也參與了計(jì)算
            Parallel.Invoke(
                () => { DoSomething("并行1-1"); },
                () => { DoSomething("并行1-2"); },
                () => { DoSomething("并行1-3"); },
                () => { DoSomething("并行1-4"); },
                () => { DoSomething("并行1-5"); });
            Console.WriteLine("*************并行結(jié)束************");
            Console.ReadLine();
        }

public static void Test2()
        {
            //并行編程 
            Console.WriteLine($"并行編程開(kāi)始，主線程Id:{Thread.CurrentThread.ManagedThreadId}");
            Console.WriteLine("【示例2】");
            //示例2：
            //定義要執(zhí)行的線程數(shù)量
            Parallel.For(0, 5, t =>
            {
                int a = t;
                DoSomething($"并行2-{a}");

            });
            Console.WriteLine("*************并行結(jié)束************");
            Console.ReadLine();
        }

public static void Test3()
        {
            //并行編程 
            Console.WriteLine($"并行編程開(kāi)始，主線程Id:{Thread.CurrentThread.ManagedThreadId}");
            Console.WriteLine("【示例3】");
            ParallelOptions options = new ParallelOptions()
            {
                MaxDegreeOfParallelism = 3//執(zhí)行線程的最大并發(fā)數(shù)量,執(zhí)行完成一個(gè)，就接著開(kāi)啟一個(gè)
            };

            //遍歷集合，根據(jù)集合數(shù)量執(zhí)行線程數(shù)量
            Parallel.ForEach(new List<string> { "a", "b", "c", "d", "e", "f", "g" }, options, (t, status) =>

            {
                //status.Break();//這一次結(jié)束。
                //status.Stop();//整個(gè)Parallel結(jié)束掉，Break和Stop不可以共存
                DoSomething($"并行4-{t}");
            });
        }

/// <summary>
        /// 異步寫(xiě)入文件
        /// </summary>
        /// <returns></returns>
        public async Task WriteTextAsync()
        {
            var path = "temp.txt"; //文件名
            var content = Guid.NewGuid().ToString(); //寫(xiě)入內(nèi)容

            using (var fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, bufferSize: 4096, useAsync: true))
            {
                var buffer = Encoding.UTF8.GetBytes(content);
                await fs.WriteAsync(buffer, 0, buffer.Length);
            }
        }

/// <summary>
        /// 異步讀取文本
        /// </summary>
        /// <returns></returns>
        public static async Task ReadTextAsync()
        {
            var fileName = "temp.txt"; //文件名
            using (var fs = new FileStream(fileName,
                                           FileMode.OpenOrCreate, FileAccess.Read, FileShare.None, bufferSize: 4096, useAsync: true))
            {
                var sb = new StringBuilder();
                var buffer = new byte[4096]; 
                var readLength = 0;

                while ((readLength = await fs.ReadAsync(buffer, 0, buffer.Length)) != 0)
                {
                    var text = Encoding.UTF8.GetString(buffer, 0, readLength);
                    sb.Append(text);
                }

                Console.WriteLine("讀取文件內(nèi)容:"+sb.ToString());
            }
        }