C#多线程总结

线程的创建

Thread

            var thread = new Thread(() => 
            {
                Console.WriteLine("thread start:" + Thread.CurrentThread.ManagedThreadId);  //ManagedThreadId为线程的id
                Thread.Sleep(10000);
                Console.WriteLine("thread end:" + Thread.CurrentThread.ManagedThreadId);
            });
            //设置是否为后台线程：
            //  前台线程：所有前台线程执行结束后，该进程才会关闭退出（主线程和通过Thread类创建的线程默认是前台线程）
            //  后台线程：所有前台结束后，后台线程就会立即结束(不管是否执行完成都会结束)
            thread.IsBackground = true;
            thread.Start();//开启线程，不传递参数

            //传递参数的
            var thread1 = new Thread(param => 
            {
                Thread.Sleep(3000);
                Console.WriteLine(param);
            });
            thread1.Start("val");
            thread1.Join(); //等待线程执行完成（使当前调用Join的线程阻塞）
            //暂停和恢复线程都标志为已过时了，不建议使用
            //thread1.Suspend();  
            //thread1.Resume();
            //设置线程的优先级，注意：在NT内核的Windows平台上建议不使用优先级来影响线程优先调度的行为，因为根本没法预期一个高优先级的线程必然会先于一个低优先级的线程执行，所以也就失去了控制线程调度的价值
            //thread1.Priority = ThreadPriority.Highest; 
            //thread1.Abort();    //暴力的终止线程，一般不建议使用

Sleep/ SpinWait

Sleep与SpinWait的区别：

使用Thread.Sleep()会导致等待过于进行切换，等待时间不准确，而且会由用户模式切换到内核模式；使用SpinWait(一个轻量同步类型(结构体))来进行等待的处理，等待过程中会使用自旋等待，从而避免线程频繁的用户模式和内核模式切换，一般用于短时的等待操作：

            //参数一为Func<bool>，就是自旋时的循环体，直到返回true或者过时为止
            SpinWait.SpinUntil(() =>
            {
                Console.WriteLine("Spin Waiting");
                return false;
            }, 1000);
            SpinWait.SpinUntil(() => false, 1000); //返回false会进入等待状态，类似于Thread.Sleep()等待，但是会盘旋CPU周期，在短期内等待事件准确度都高于Sleep 
            SpinWait.SpinUntil(() => true, 1000);  //返回true会自动跳出等待状态，不再休眠，继续执行下面的代码

使用SpinWait做一些多线程的流程控制

            int i = 0;
            Task.Run(() => 
            {
                Thread.Sleep(1000); //模拟一些操作
                Interlocked.Increment(ref i);
            });
            Task.Run(() =>
            {
                Thread.Sleep(1000); //模拟一些操作
                SpinWait.SpinUntil(() => i == 1);    //等待1完成
                Thread.Sleep(1000); //模拟一些操作
                Interlocked.Increment(ref i);
            });
            SpinWait.SpinUntil(() => i == 2);    //等待所有流程完成
            Console.WriteLine("Completed!");

ThreadPool

通过线程池创建线程，池中的线程都是后台线程

使用线程更应该使用线程池来创建：比如一个服务器需要处理成千上万个客户端链接，并处理不同的请求时，这种情况下如果简单通过Thread来创建线程处理，那么就是需要创建成千上万个线程了，那么多线程会频繁的调度切换，资源浪费严重、性能十分低下，因此需要线程池来维护多线程（会动态调整线程数量）

            ThreadPool.QueueUserWorkItem(param => 
            {
                Console.WriteLine(param);   //val，param为传递过来的参数
            }, "val");

Task

通过Task来创建线程（线程也是由线程池维护，也是后台线程），比ThreadPool更加灵活方便

            var tasks = new List<Task>();
            tasks.Add(Task.Factory.StartNew(param => 
            {
                Thread.Sleep(5000);
                Console.WriteLine(param);
            }, "val"));
            tasks.Add(Task.Run(() => Console.WriteLine(Thread.CurrentThread.ManagedThreadId)));
            Task.WaitAny(tasks.ToArray());  //等待（阻塞）只要有一个Task执行完毕就不再等待了
            Task.WaitAll(tasks.ToArray());  //等待（阻塞）所有Task执行结束

            //带返回值的
            var task = Task.Run<string>(() => 
            {
                Thread.Sleep(3000);
                return "rtn Val";
            });   
            //task.Wait();  //等待执行结束
            Console.WriteLine(task.Result); //获取返回的结果，调用Result就会等待Task执行结束返回结果，因此也会造成阻塞

ConfigureAwait

            Task.Run(() =>
            {
                Thread.Sleep(1000);
                Console.WriteLine("Async");

                //ConfigureAwait为false发生异常的时候不会回取捕捉原始Context(上下文)，
                //这样子就是在线程池中运行，而不是在ASP.NET/UI的Context的上下文线程中运
                //行了，这样子性能上提高了
            }).ConfigureAwait(false);   

Thread.Sleep()与Task.Delay()

            //    Thread.Sleep是同步延迟, Task.Delay异步延迟;
            //    Thread.Sleep不能取消，Task.Delay可以。
            Task.Run(async () =>
            {
                //将任务延迟1000毫秒后运行，如果无限等待那么指定为-1
                await Task.Delay(1000);
                Console.WriteLine("Task Start");
                //CancellationToken设置为true就是标志Task任务取消，为false和 await Task.Delay(1000)一样将任务延迟1000毫秒后运行
                await Task.Delay(1000, new CancellationToken(true));
                Console.WriteLine("这里不会被执行，因为任务取消了~");  
            });

Task与async/await

        public class TaskTest
        {
            public Task DoAsync(string param)
            {
                return Task.Run(() =>
                {
                    //调用Result会阻塞直到获取到返回值
                    NextDo(LongTimeDoAsync(param).Result);
                });
            }

            public async Task Do1Async(string param)
            {
                //对比上面的DoAsync方法，执行结果一样，但是使用async/await配合Task使用，节省了代码量，而且也方便外部的调用和等待处理等等
                NextDo(await LongTimeDoAsync(param));
            }

            async Task<object> LongTimeDoAsync(string param)
            {
                return await Task.Run<object>(() =>
                {
                    //执行一些耗时的操作
                    Thread.Sleep(10000);
                    return param + " ok";
                });
            }

            void NextDo(object result)
            {
                Console.WriteLine(result);
            }
        }

调用：

            var test = new TaskTest();
            test.DoAsync("DoAsync");
            test.Do1Async("Do1Async");

 

并发集合

在System.Collections.Concurrent下的集合类，都是些多线程安全集合，而ConcurrentXXX为并发集合，有不少方法带有Try前缀，这些方法在多线程下执行过程中可能会失败返回false，因此不要相信这些操作会一定完成任务，需要判断返回的结果；还有BlockingCollection<T>是阻塞集合，就是添加/获取元素的时候会阻塞线程直到操作完成。

ConcurrentDictionary

            ConcurrentDictionary<string, string> dict = new ConcurrentDictionary<string, string>();
            dict.TryAdd("key1", "val1");
            string val;
            dict.TryGetValue("key1", out val);
            dict.TryUpdate("key1", "val2", val);//最后参数为比较的值，值不同才会更新
            dict.TryRemove("key1", out val);
            Console.WriteLine(val); //val2

            val = dict.GetOrAdd("key1", "val3");
            val = dict.GetOrAdd("key1", "val4");
            Console.WriteLine(val); //val3

            dict["key1"] = null;
            //对于AddOrUpdate方法，如果指定的key已经存在，那么调用第三个参数进行UpdateValue
            //如果不存在，那么调用第二个参数进行AddValue
            val = dict.AddOrUpdate("key1", "val5", (key, oldVal) => 
            {
                Console.WriteLine(oldVal);  //null
                return "val6";
            });
            Console.WriteLine(val); //val6

            val = dict.AddOrUpdate("key2", key => 
            {
                return "val7";
            }, (key, oldVal) =>
            {
                Console.WriteLine(oldVal);
                return "val8";
            });
            Console.WriteLine(val); //val7

ConcurrentQueue

            ConcurrentQueue<string> q = new ConcurrentQueue<string>();
            q.Enqueue("val1");
            q.Enqueue("val2");
            string val;
            q.TryPeek(out val);
            Console.WriteLine(val); //val1
            q.TryDequeue(out val);
            Console.WriteLine(val); //val1

ConcurrentStack

            ConcurrentStack<string> s = new ConcurrentStack<string>();
            s.Push("val1");
            s.Push("val2");
            string val;
            s.TryPeek(out val);
            Console.WriteLine(val); //val2
            s.TryPop(out val);
            Console.WriteLine(val); //val2

ConcurrentBag

            //ConcurrentBag：无序的并发集合（相同元素可重复添加）
            ConcurrentBag<object> bag = new ConcurrentBag<object>();
            var obj = new object();
            bag.Add(obj);
            bag.Add(obj);
            Console.WriteLine(bag.Count);   //2
            while (!bag.IsEmpty)    //判断集合是否为空
            {
                bag.TryTake(out obj);   //获取
            }

 

并行计算

Parallel

For

            //并行计算，调用的线程会等待直到并行执行完毕
            Parallel.For(2, 10, i => 
            {
                //i的值为[2, 10)（不包括10），就是执行次数为8次
                Console.WriteLine(i);
            });

            //MaxDegreeOfParallelism为指定并行计算的最大线程数
            Parallel.For(1, 10, new ParallelOptions { MaxDegreeOfParallelism = 3 }, i =>
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
            });

            int result = 0;
            Parallel.For(0, 100, new ParallelOptions { MaxDegreeOfParallelism = 4 },
               //初始化localState
               () => 0,
               //并行循环体(i为[0, 100)，也就是会执行100次)
               (i, loop, localState) =>
               {
                   //localState从0开始，不断累加i的值
                   return localState + i;   //循环体中返回的结果会在下面的回调中进行值的合并(结果的合并必须在下面进行)
               },
               //合并计算的结果
               localState => Interlocked.Add(ref result, localState)
            );
            Console.WriteLine("真实结果: {0}. 预期结果：4950.", result);

ForEach

            int aCount = 0;
            //并行计算，会等待(阻塞)直到执行完成
            Parallel.ForEach("aaaabbbbbcccc",
                //设置并行计算的最大线程数
                new ParallelOptions { MaxDegreeOfParallelism = 4 },
                c =>
                {
                    //计算'a'的个数
                    if (c == 'a')
                    {
                        Interlocked.Increment(ref aCount);
                    }
                });
            Console.WriteLine(aCount); //4

            //Partitioner为设置策略分区：例如值范围为[0, 100]，每个区域的大小为4
            Parallel.ForEach(Partitioner.Create(0, 10, 4),
                val =>
                {
                    Console.WriteLine(val); //val是一个Tuple<int, int>，分成的区间值有：(0, 4),(4, 8),(8, 10)
                });

            int result = 0;
            Parallel.ForEach(Partitioner.Create(1, 101, 10),
                val =>
                {
                    for (int i = val.Item1; i < val.Item2; i++)
                    {
                        Interlocked.Add(ref result, i);
                    }
                });
            Console.WriteLine(result);  //输出：5050

            int[] vals = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            int sum = 0;
            Parallel.ForEach(
                    vals,
                    //localSum的初始值
                    () => 0,
                    //并行执行的循环体
                    (val, loopState, localSum) =>
                    {
                        //val为集合vals中的值
                        //这里的操作是并行计算集合中值的总和
                        localSum += val;
                        return localSum;    //循环体中返回的结果会在下面的回调中进行值的合并(结果的合并必须在下面进行)
                    },
                    //合并计算的结果
                    (localSum) => Interlocked.Add(ref sum, localSum)
                );
            Console.WriteLine(sum);    //55

Invoke

            int i = 0;
            Action action = () => Interlocked.Increment(ref i);
            Action action1 = () => Interlocked.Add(ref i, 2);
            Action action2 = () => Interlocked.Add(ref i, 3);
            //并行调用Action，调用的线程会等待直到并行执行完毕
            Parallel.Invoke(action, action1, action2);
            //Parallel.Invoke(new ParallelOptions { MaxDegreeOfParallelism = 3 }, action, action1, action2);
            Console.WriteLine(i);   //输出：6

PLINQ

            var list = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            //PLINQ，进行并行计算，但是PLINQ不能限定并行计算时的最大线程数
            list.AsParallel().ForAll(l =>
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
            });

            Console.WriteLine(list.AsParallel().Where(l => l > 5).Sum());   //40
            Console.WriteLine(list.AsParallel().Aggregate((sum, val) =>
            {
                return val + sum + 1;
            }));    //64

            var list1 = new int[] { 1, 1, 1, 2, 2, 2, 3 };
            Console.WriteLine(list1.AsParallel().GroupBy(l => l).Count());  //3

 

线程同步

lock(Monitor) / SpinLock

lock

lock使用起来很简单，为Monitor封装的语法糖：

lock (obj)
{
    //同步操作.
}

锁的对象不要为类型Type，因为性能上会损失大：lock(typeof(Class))

Monitor

            Monitor.Enter(obj);
            try
            {
                //同步操作
            }
            finally
            {
                Monitor.Exit(obj);
            }

使用Monitor的主要优点就是可设置等待的超时值：

                bool lockTaken = false;
                Monitor.TryEnter(obj, 1000, ref lockTaken);
                if (lockTaken)
                {
                    try
                    {
                        //同步操作
                    }
                    finally
                    {
                        Monitor.Exit(obj);
                    }
                }
                else
                {
                    Console.WriteLine("超时了");
                }

SpinLock自旋锁/细粒度锁

自旋锁：就是在等待的过程中会做自旋等待，避免线程频繁的用户模式和内核模式切换

msdn中的说明：

自旋锁可用于叶级锁定，此时在大小方面或由于垃圾回收压力，使用Monitor（lock）所隐含的对象分配消耗过多。自旋锁非常有助于避免阻塞，但是如果预期有大量阻塞，由于旋转过多，您可能不应该使用自旋锁。当锁是细粒度的并且数量巨大（例如链接的列表中每个节点一个锁）时以及锁保持时间总是非常短时，旋转可能非常有帮助。通常，在保持一个旋锁时，应避免任何这些操作：

• 阻塞，
• 调用本身可能阻塞的任何内容，
• 一次保持多个自旋锁，
• 进行动态调度的调用（接口和虚方法）
• 在某一方不拥有的任何代码中进行动态调度的调用，或
• 分配内存。

简单封装：

        public class SpinLockEx
        {
            SpinLock _slock = new SpinLock();
            public void Lock(Action action)
            {
                bool lockTaken = false;
                try
                {
                    _slock.Enter(ref lockTaken);
                    action();
                }
                finally
                {
                    if(lockTaken) _slock.Exit();
                }
            }
        }

使用：

            int ival1 = 0, ival2 = 0;
            List<Task> list = new List<Task>();
            var slock = new SpinLockEx();
            for (int i = 0; i < 10000; i++)
            {
                list.Add(Task.Run(() =>
                {
                    slock.Lock(() =>
                    {
                        ival1++;    //注意：这里只是模拟多线程操作共享资源，对于数值操作应该使用Interlocked
                    });
                }));
                list.Add(Task.Run(() =>
                {
                    ival2++;
                }));
            }
            Task.WaitAll(list.ToArray());
            Console.WriteLine(ival1);   //值计算准确：10000
            Console.WriteLine(ival2);   //值计算可能会不准确，因为没有做多线程安全

 

Mutex

Mutex互斥锁(互斥对象)的使用作用和Monitor(lock)差不多，但是Mutex是内核对象，可以跨进程共享的，不过性能方面Monitor比较高，因为Mutex控制需要从用户模式到内核模式，而Monitor是用户模式下控制的。

            bool isNew;
            //参数一：主调线程是否初始拥有互斥对象
            //参数二：定义互斥对象的名称(命名互斥对象跨进程共享)
            //参数三：该命名的互斥对象是否为新创建的
            var m = new Mutex(false, "Tom123", out isNew);
            if (m.WaitOne())    //等待互斥对象拥有权（一个线程拥有了，另一个线程等待拥有权，直到拥有的线程调用ReleaseMutex释放）
            { 
                try
                {
                    //同步操作
                    Thread.Sleep(3000);
                    Console.WriteLine("do something");
                }
                finally
                {
                    m.ReleaseMutex();    //释放拥有权
                }
            }
            else
            {
                //等待失败，如果WaitOne的时候有指定超时值，否则会一直等待
            }

            bool isNew;
            //因为命名的互斥对象是跨进程的，因此通过第三个参数判断互斥对象是否已经存在，
            //可做一些检测程序是否已经运行的操作
            m = new Mutex(false, "Tom123", out isNew);
            if (!isNew)
            {
                Console.WriteLine("该程序已经运行！");
            }
            m.Dispose();//记住需要释放资源

 

Event

事件对象也是内核对象，事件对象分为 人工重置 和 自动重置：

AutoResetEvent(自动重置)

            AutoResetEvent e = new AutoResetEvent(true);    //参数为是否初始化为有信号状态
            if (e.WaitOne()) //等待事件对象，直到有信号状态（如果没有指定超时值）
            {
                //对象自动重置的事件对象来说：等待成功，那么就会自动设置为无信号状态（因此并不需要调用e.Reset()），因此性质和互斥对象差不多
                try
                {
                    //同步操作
                    Thread.Sleep(3000);
                    Console.WriteLine("do something");
                }
                finally
                {
                    e.Set();//设置为有信号状态
                }
            }
            else
            {
                //等待失败，如果WaitOne的时候指定超时值，否则会一直等待
            }
            e.Dispose();    //使用完成需要释放对象资源，因为是内核对象

ManualResetEvent/Slim (人工重置)

            //人工重置的事件对象需要手动设置为无信号状态，因此人工重置的事件对象不适合做多线程同步锁，
            //可用于做一些程序启动时的初始化操作，例如：加载某些大文件，加载完成后通知加载完成，而这些过程通过人工重置事件对象控制
            //带Slim的事件对象，性能上会更好(运用了细粒度锁)，就是参数二中可以指定等待时自旋的次数，目的防止等待的过程中频繁的切换线程
            var e = new ManualResetEventSlim(false, 100);   //参数一为是否初始化为有信号状态
            Task.Run(() =>
            {
                Console.WriteLine("加载大文件开始");
                Thread.Sleep(10000);
                Console.WriteLine("加载完成");
                e.Set();//设置为有信号状态
            });
            Task.Run(() =>
            {
                e.Wait();   //等待文件加载完成
                Console.WriteLine("加载完成后，do something...");
            });

 

ReaderWriterLock/Slim

ReaderWriterLock就是用于允许多个读取器(读取的时候不能写入)，而只能有一个写入器(写入时锁定)来管理，对于ReaderWriterLockSlim的性能上会更好(运用了细粒度锁)，可避免潜在的死锁的很多情况。

        public class TestRW : IDisposable
        {
            ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();
            StringBuilder _sb = new StringBuilder();
            public void Append(string val)
            {
                try
                {
                    _rwLock.EnterWriteLock();  //获取读取器
                    _sb.Append(val);
                }
                finally
                {
                    _rwLock.ExitWriteLock();//释放读取器
                }
            }

            public override string ToString()
            {
                try
                {
                    _rwLock.EnterReadLock(); //获取写入器  
                    return _sb.ToString();
                }
                finally
                {
                    _rwLock.ExitReadLock();//释放写入器
                }
            }

            public void Dispose()
            {
                _rwLock.Dispose();  //需要释放资源
            }
        }

使用

            List<Task> tasks = new List<Task>();
            TestRW rw = new TestRW();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < 1000; i++)
            {
                tasks.Add(Task.Run(() =>
                {
                    sb.Append("1");
                }));
                tasks.Add(Task.Run(() =>
                {
                    rw.Append("1");
                }));
            }
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine(sb.ToString().Length);    //StringBuilder不是多线程安全的，因此结果会失真
            Console.WriteLine(rw.ToString().Length);    //使用了读写锁，因此多线程安全
            rw.Dispose();   //记住需要释放资源

 

Semaphore/Slim

信号量是一种计数互斥锁，计数为0时阻塞线程，可用于多线程的限流操作，SemaphoreSlim运用了细粒度锁，性能更优：

            var tasks = new List<Task>();
            int ival = 0;
            //参数一：初始化信号的数量
            //参数二：信号的最大数量
            var smp = new SemaphoreSlim(10, 10);
            for (int i = 0; i < 100; i++)
            {
                tasks.Add(Task.Run(() =>
                {
                    if (smp.Wait(100))  //等待成功，会减少一个信号量，直到信号量为0
                    {
                        Thread.Sleep(1000);  //模拟一些操作
                        Console.WriteLine(Interlocked.Increment(ref ival));
                        //smp.Release();    //释放一个信号量
                    }
                    else
                    {
                        //等待失败，如果Wait的时候有指定超时值，否则会一直等待
                        Console.WriteLine("超时了~");
                    }
                }));
            }
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine(smp.CurrentCount);    //当前的信号量数量
            smp.Dispose();  //记住需要释放资源

 

CountdownEvent

CountdownEvent（倒计器）的性质和Semaphore相反，等待(阻塞)直到信号为0为止（当倒计数为0时，触发完成，停止等待），可以做fork-join（并行计算）的控制：

            var datas = new int[]{ 1,2,3,4,5,6,7,8,9,10 };
            //倒计器：当倒计数为0时，触发完成，停止等待
            using (var c = new CountdownEvent(1))   //参数为初始化倒计数(如果指定为0，那么初始状态为完成，需要调用Reset重置，不然使用会抛异常)
            {
                Console.WriteLine(c.CurrentCount);  //当前的倒计数
                // fork work:
                for (int i = 0; i < datas.Length; i++)
                {
                    c.AddCount();   //增加倒计数(可指定增加的数量)
                    ThreadPool.QueueUserWorkItem(idx =>
                    {
                        Interlocked.Increment(ref datas[(int)idx]);
                        c.Signal(); //注册一个(可指定数量)信号，并且CurrentCount倒计数减一(可指定数量)
                    }, i);
                }
                c.Signal();
                // Join with work.
                c.Wait();   //等待(阻塞)直到计数为0为止，可以指定等待的时间
                Console.WriteLine("Completed!");
                //c.Reset(1);   //重置初始化的倒计数，如果等待完成之后想继续使用倒计器，那么就需要调用这个方法重置了，不然会抛异常
            }
            Console.WriteLine(JsonConvert.SerializeObject(datas));  //[2,3,4,5,6,7,8,9,10,11]

 

Barrier

Barrier（屏障/关卡）适用于并行操作分阶段执行，并且每一阶段中各任务需要进行同步，使用Barrier可以在并行操作中的所有任务都达到相应的关卡之前，阻止各个任务继续执行：

            int i = 0;
            //参数一：初始化参与者
            //参数二：关卡完成触发的事件
            var b = new Barrier(2, (bar) =>
            {
                Console.WriteLine(i);
            });
            //增加参与者数量
            b.AddParticipant();
            b.AddParticipants(2);
            //移除参与者数量
            b.RemoveParticipant();
            //参与者数量
            Console.WriteLine(b.ParticipantCount);  //4

            Action action = () =>
            {
                Interlocked.Increment(ref i);
                //设置关卡1：
                //用信号通知有参与者(线程)已达到关卡，而且到达的参与者(线程)会一直等待(可指定超时值)，
                //直到所有参与者都达到关卡为止(就是通知的信号达到ParticipantCount的时候)，并且触发Barrier构造函数指定的事件
                b.SignalAndWait();  //等待完成之后会触发关卡完成事件，输出：4

                Interlocked.Add(ref i, 2);
                //设置关卡2：
                b.SignalAndWait();  //输出：12

                Interlocked.Add(ref i, 4);
                //设置关卡3：
                b.SignalAndWait();  //输出：28
            };

            //参与者(线程)的数量不能大于ParticipantCount，否则会抛异常
            Task.Run(action);   //设置一个参与者(线程)
            Parallel.Invoke(action, action, action); //设置三个参与者(线程)

 

Timer

定时器，可以做一些定时的控制操作：

            //参数一：定时触发的事件
            //参数二：传递到事件的参数
            //参数三：为第一次触发事件的定时时间
            //参数四：为周期时间(第一次触发事件之后，再次触发事件的周期，指定了这个参数，那么就会按周期时间循环执行了，如果设为0就只会执行一次事件)
            var timer = new Timer(val =>
            {
                Console.WriteLine(val);
            }, "val", 1000, 1000);  //这里的设置为每秒执行一次事件
            //timer.Dispose();  //记住需要释放资源

 

Interlocked

使用原子操作保证值类型操作的原子性，以保证值类型线程间同步，性能方面比使用lock更优，因此保证值类型多线程安全更应该优先考虑使用Interlocked：

        public class IntEx
        {
            int _val;
            public int Val
            {
                get { return _val; }
                set
                {
                    Interlocked.CompareExchange(ref _val, value, _val);
                }
            }

            public IntEx() { }
            public IntEx(int ival)
            {
                _val = ival;
            }

            public int Add(int ival)
            {
                return Interlocked.Add(ref _val, ival);
            }

            public int Incre()
            {
                return Interlocked.Increment(ref _val);
            }

            public int Decre()
            {
                return Interlocked.Decrement(ref _val);
            }
        }

使用：

            var tasks = new List<Task>();
            var itl = new IntEx();
            int ival = 0;
            for (int i = 0; i < 1000; i++)
            {
                tasks.Add(Task.Run(() => 
                {
                    ival++;
                }));
                tasks.Add(Task.Run(() => 
                {
                    itl.Incre();
                    //itl.Val++;    //也不要这样进行自增，就算使用了Interlocked.CompareExchange
                }));
            }
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine(ival);    //没有使用Interlocked以保证操作的原子性，因此数据会失真
            Console.WriteLine(itl.Val); //数据正确   

 使用Interlocked进行多线程的控制：

        public class OneDo
        {
            int _ival = 0;
            public event Action Action;

            public OneDo(Action action)
            {
                if (action == null) throw new ArgumentNullException("action");
                Action = action;
            }

            public void Release()
            {
                Interlocked.CompareExchange(ref _ival, 0, _ival);
            }

            public bool IsDoing
            {
                get { return _ival > 0; }
            }

            bool CanDo()
            {
                if (_ival <= 0)
                {
                    if (Interlocked.Increment(ref _ival) <= 1)
                    {
                        return true;
                    }
                }
                return false;
            }

            public bool Do()
            {
                if (CanDo())
                {
                    Action();
                    return true;
                }
                return false;
            }

            public bool DoAndRelease()
            {
                if (CanDo())
                {
                    Action();
                    Release();
                    return true;
                }
                return false;
            }

            public bool DoAsync()
            {
                if (CanDo())
                {
                    Task.Run(() =>
                    {
                        Action();
                    });
                    return true;
                }
                return false;
            }

            public bool DoAndReleaseAsync()
            {
                if (CanDo())
                {
                    Task.Run(() =>
                    {
                        Action();
                        Release();
                    });
                    return true;
                }
                return false;
            }
        }

使用：

            var onedo = new OneDo(() => Console.WriteLine("One do!"));
            for (int i = 0; i < 100; i++)
            {
                Task.Run(() => 
                {
                    onedo.Do(); //只会执行一次，除非调用Release，因此可用于做一些初始化操作
                });
            }


            int val = 0;
            var onedo1 = new OneDo(() => Console.WriteLine("One do! " + Interlocked.Increment(ref val)));
            for (int i = 0; i < 100; i++)
            {
                Task.Run(() =>
                {
                    SpinWait.SpinUntil(() => onedo1.DoAndRelease()); //每次只被一个线程执行，使用SpinWait等待执行成功为止
                });
            }

 

TPL Dataflow

TPL Dataflow是非常强大的多线程高并发数据流控制类库，

.NET中使用需要在NuGet中搜索Microsoft.Tpl.Dataflow加载，.net core可直接使用。

            //数据流Buffer
            var buf = new BufferBlock<string>();
            //数据流处理器(处理器是异步处理数据的)
            var action = new ActionBlock<string>(val =>
            {
                //以FIFO形式处理数据
                Console.WriteLine(val + "，tid=" + Thread.CurrentThread.ManagedThreadId);
            }, new ExecutionDataflowBlockOptions()
            {
                //设置并行处理的线程数，默认为1
                MaxDegreeOfParallelism = 1,
            });
            //连接处理器
            buf.LinkTo(action);
            //添加数据到流中，连接到了处理器，数据就会流向处理器中进行处理
            for (int i = 0; i < 100; i++)
            {
                buf.Post(i.ToString());
            }

            var buf1 = new BufferBlock<string>();
            var action1 = new ActionBlock<string>(val =>
            {
                Console.WriteLine(val);
            });
            //buf1.LinkTo(action1);
            Task.Run(() =>
            {
                Thread.Sleep(3000);
                buf1.LinkTo(action1);
            });
            for (int i = 0; i < 10; i++)
            {
                buf1.Post(i.ToString());
            }

            buf1.Complete(); //发送完成信号（不会阻塞），并且停止接受数据，就是后续的添加是不会被处理的
            buf1.Post("asdf");  //这里添加不会被处理
            //Completion属性只有在调用了Complete()后才会有效
            buf1.Completion.Wait();  //这里会等待(阻塞)，直到连接到处理器为止(就是：如果没有调用LinkTo(action)，那么会一直等待，可设置超时值)

            //对于Action的Complete()，需要Buffer调用Complete并且Completion.Wait才有效
            action1.Complete();
            //Completion属性只有在设置了Complete方法后才会有效
            action1.Completion.Wait();   //这里会等待(阻塞)，等待Action把所有数据处理完成为止(可设置超时值)

            var buf = new BufferBlock<string>();
            //负载均衡：通过设置多个处理器，并且设置处理器的BoundedCapacity(限容值)，那么处理器就会按照BoundedCapacity均衡处理数据了
            //注意：每个处理器都应该设置BoundedCapacity，如果存在没有设置BoundedCapacity(或设为-1)的处理器，那么数据流可能都只到该处理器进行处理了
            buf.LinkTo(new ActionBlock<string>(val =>
            {
                Console.WriteLine(val + "，Tom");
            }, new ExecutionDataflowBlockOptions()
            {
                BoundedCapacity = 10,
            }));
            buf.LinkTo(new ActionBlock<string>(val =>
            {
                Console.WriteLine(val + "，Jane");
            }, new ExecutionDataflowBlockOptions()
            {
                BoundedCapacity = 10,
            }));
            for (int i = 0; i < 100; i++)
            {
                buf.Post(i.ToString());
            }

多播

            //多播，就是连接的ActionBlock都会收到数据
            BroadcastBlock<int> broadcast = new BroadcastBlock<int>(val => val);
            broadcast.LinkTo(new ActionBlock<int>(val => Console.WriteLine(val + "，A")));
            broadcast.LinkTo(new ActionBlock<int>(val => Console.WriteLine(val + "，B")));
            for (int i = 0; i < 10; i++)
            {
                broadcast.Post(i);
            }

            BroadcastBlock<int> broadcast = new BroadcastBlock<int>(val => val);
            broadcast.LinkTo(new ActionBlock<int>(val => Console.WriteLine(val + "，A")));
            for (int i = 0; i < 10; i++)
            {
                broadcast.Post(i);
            }
            Thread.Sleep(1000);
            //连接ActionBlock应该在Post数据之前，不然在之后连接的ActionBlock就只接收到最后一个数据了
            broadcast.LinkTo(new ActionBlock<int>(val => Console.WriteLine(val + "，B")));

TPL Dataflow更详细使用说明可参考这篇博文：

http://www.cnblogs.com/haoxinyue/archive/2013/03/01/2938959.htm