C#多线程下的调优

Python微信订餐小程序课程视频

https://edu.youkuaiyun.com/course/detail/36074

Python实战量化交易理财系统

https://edu.youkuaiyun.com/course/detail/35475目录

• 一、原子操作
  • 1.基于Lock实现
  • 2.基于CAS实现
  • 3.自旋锁SpinLock
  • 4.读写锁ReaderWriterLockSlim
• 二、线程安全
  • 1.线程安全集合
  • 2.线程安全字典
• 三、线程池
  • 1.通过QueueUserWorkItem启动工作者线程
  • 2.线程池等待（信号量）
  • 3.Task
  • 4.线程池调度原理
• 四、并行
• 五、异步IO
  • 1.异步IO于同步IO比较
  • 2.异步读写文件

---

回到顶部# 一、原子操作

先看一段问题代码

 /// 
        /// 获取自增
 /// 
        public static void GetIncrement()
 {
 long result = 0;
 Console.WriteLine("开始计算");
 //10个并发执行
            Parallel.For(0, 10, (i) =>
 {
 for (int j = 0; j < 10000; j++)
 {
 result++;
 }
 });
 Console.WriteLine("结束计算");
 Console.WriteLine($"result正确值应为：{10000 * 10}");
 Console.WriteLine($"result 现值为：{result}");
 Console.ReadLine();
 }

这是多线程下，result的值不同步的原因。

1.基于Lock实现

平时大家用的最多的应该就是加锁了，同一时间，只有一个线程进入代码块。

实现代码：

 private static Object \_obj = new object();
　　　　　/// 
        /// 原子操作基于Lock实现
 /// 
        public static void AtomicityForLock()
 {
 long result = 0;
 Console.WriteLine("开始计算");
 //10个并发执行
           Parallel.For(0, 10, (i) =>
 {
 //lock锁
                lock (\_obj)
 {
 for (int j = 0; j < 10000; j++)
 {
 result++;
 }
 }
 });
 Console.WriteLine("结束计算");
 Console.WriteLine($"result正确值应为：{10000 * 10}");
 Console.WriteLine($"result 现值为：{result}");
 Console.ReadLine();

 }

结果：

2.基于CAS实现

CAS是一种有名的无锁算法。无锁编程，即不适用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步。　　CAS在.NET中的实现类是Interlocked，内部提供很多原子操作的方法，最终都是调用Interlocked.CompareExchange(ref out,更新值，期望值) //基于内存屏障的方式操作 （七个步骤）说到线程安全，不要一下子就想到加锁，尤其是可能会调用频繁或者是要求高性能的场合。

• CAS（Compare And Swap）比较并替换，是线程并发运行时用到的一种技术
• CAS是原子操作，保证并发安全，而不能保证并发同步
• CAS是CPU的一个指令（需要JNI调用Native方法，才能调用CPU的指令）
• CAS是非阻塞的、轻量级的乐观锁

CAS的适用场景

读多写少：如果有大量的写操作，CPU开销可能会过大，因为冲突失败后会不断重试（自旋），这个过程中会消耗CPU　　单个变量原子操作：CAS机制所保证的只是一个变量的原子操作，而不能保证整个代码块的原子性，比如需要保证三个变量共同进行原子性的更新，就不得不使用悲观锁了

Interlocked主要函数如下：Interlocked.Increment　　　　原子操作，递增指定变量的值并存储结果。Interlocked.Decrement　　 原子操作，递减指定变量的值并存储结果。Interlocked.Add　　　　　　　 原子操作，添加两个整数并用两者的和替换第一个整数Interlocked.Exchange　　原子操作，赋值Interlocked.CompareExchange(ref a, b, c); 原子操作，a参数和c参数比较， 相等b替换a，不相等不替换。方法返回值始终是第一个参数的原值，也就是内存里的值

用Interlocked.Increment实现上面自增功能

代码：

　　　　 /// 
        /// 自增CAS实现
 /// 
        public static void AtomicityForInterLock()
 {
 long result = 0;
 Console.WriteLine("开始计算");
 Parallel.For(0, 10, (i) =>
 {
 for (int j = 0; j < 10000; j++)
 {
 //自增
                    Interlocked.Increment(ref result);
 }
 });
 Console.WriteLine($"结束计算");
 Console.WriteLine($"result正确值应为：{10000 * 10}");
 Console.WriteLine($"result 现值为：{result}");
 Console.ReadLine();
 }

结果：

Interlocked下原子操作的方法最终都是调用Interlocked.CompareExchange(ref a, b, c)实现的，现在我们利用CompareExchange自己实现一个原子操作功能

实现“一个变量自增到10000，然后又初始化到1开始自增的功能“

代码：

　　　　/// 
        /// 基于CAS原子操作自己写
 /// 
        public static void AtomicityForMyCalc()
 {
 long result = 0;
 Console.WriteLine("开始计算");
 
 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($"自增到达10000啦!值被初始化为1");
 }
 }
 });
 Console.WriteLine($"结束计算");

 Console.WriteLine($"result正确值应为：{10000}");
 Console.WriteLine($"result 现值为：{result}");
 Console.ReadLine();

 }

结果&#