C# golang 开10000个无限循环的性能

知乎上有人提了个问题，可惜作者已把账号注销了。
复制一下他的问题，仅讨论技术用，侵删。
问题

作者：知乎用户fLP2gX
链接：https://www.zhihu.com/question/634840187/answer/3328710757
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
最近遇见个需求，需要开2000个线程无限循环，每个循环有sleep(1),这个在其他语言很容易实现，在c#中就很难了，我试过task.delay(1)直接一秒钟10次gc。今天有空测试下多种语言的协程，都是开10000个协程无限循环，中间有个sleep(15ms)， cpu使用率rust  40%，golang 3%，c# 16%，  都是release，把我搞不自信了。cpu是11代i5 ，rust的开销简直无法忍受。为了严谨测试了系统线程，cpu使用率43%
rust代码

1. static NUM: i64 = 0;
2. async fn fff() {
3.     let t = tokio::time::Duration::from_millis(15);
4.     loop {
5.         tokio::time::sleep(t).await;
6.         if NUM > 1000 {
7.             println!("大于");
8.         }
9.     }
10. }
11. #[tokio::main]
12. async fn main() {
13.     let mut i = 0;
14.     while i < 10000 {
15.         tokio::task::spawn(fff());
16.         i = i + 1;
17.     }
18.     println!("over");
19.     let mut s = String::new();
20.     std::io::stdin().read_line(&mut s).unwrap();
21. }

复制代码

go代码

1. package main
2. import (
3.         "fmt"
4.         "time"
5. )
6. var AAA int
7. func fff() {
8.         for {
9.                 time.Sleep(time.Millisecond * 15)
10.                 if AAA > 10000 {
11.                         fmt.Println("大于")
12.                 }
13.         }
14. }
15. func main() {
16.         for i := 0; i < 10000; i++ {
17.                 go fff()
18.         }
19.         fmt.Println("begin")
20.         var s string
21.         fmt.Scanln(&s)
22. }

复制代码

c#代码

1. internal class Program
2. {
3.     static Int64 num = 0;
4.     static async void fff()
5.     {
6.         while (true)
7.         {
8.             await Task.Delay(15);
9.             if (num > 100000)
10.                 Console.WriteLine("大于");
11.         }
12.     }
13.     static void Main()
14.     {
15.         for (int i = 0; i < 10000; i++)
16.             fff();
17.         Console.WriteLine("begin");
18.         Console.ReadLine();
19.     }
20. }

复制代码

我的测试

我使用Task.Delay测试，发现速度只有30多万次/秒，然后CPU占用达到30%。
然后我又上网了找了一个时间轮算法HashedWheelTimer，使用它的Delay，经过调参，速度可以达到50多万次/秒，达到了题主的要求，但CPU占用依然高达30%。我不知道是不是我找的这个HashedWheelTimer写的不好。
我的尝试

如下代码勉强达到了题主的要求，速度可以达到50多万次/秒，CPU占用8%，比go的3%要高一些，但比用Task.Delay要好很多了。但有个缺点，就是任务延迟可能会高达500毫秒。

1. int num = 0;
3. async void func(int i)
4. {
5.     int n = 25; // 无延迟干活次数
6.     int m = 1; // 干n次活，m次延迟干活
7.     int t = 500; // 延迟干活时间，根据具体业务设置可以接受的延迟时间
8.     long count = 0;
9.     while (true)
10.     {
11.         if (count < n)
12.         {
13.             await Task.CompletedTask;
14.         }
15.         else if (count < n + m)
16.         {
17.             await Task.Delay(t); // 循环执行了若干次，休息一会，把机会让给其它循环，毕竟CPU就那么多
18.         }
19.         else
20.         {
21.             count = 0;
22.         }
23.         count++;
25.         Interlocked.Increment(ref num); // 干活
26.     }
27. }
29. for (int i = 0; i < 10000; i++)
30. {
31.     func(i);
32. }
34. _ = Task.Factory.StartNew(() =>
35. {
36.     Stopwatch sw = Stopwatch.StartNew();
37.     while (true)
38.     {
39.         Thread.Sleep(5000);
40.         double speed = num / sw.Elapsed.TotalSeconds;
41.         Console.WriteLine($"10000个循环干活总速度={speed:#### ####.0} 次/秒");
42.     }
43. }, TaskCreationOptions.LongRunning);
45. Console.WriteLine("begin");
46. Console.ReadLine();

复制代码

再次尝试

1. using System.Collections.Concurrent;
2. using System.Diagnostics;
3. using System.Runtime.CompilerServices;
5. int num = 0;
6. MyTimer myTimer = new MyTimer(15, 17000);
8. async void func(int i)
9. {
10.     while (true)
11.     {
12.         await myTimer.Delay();
13.         // Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.ffff} - {i}");
15.         Interlocked.Increment(ref num); // 干活
16.     }
17. }
19. for (int i = 0; i < 10000; i++)
20. {
21.     func(i);
22. }
24. _ = Task.Factory.StartNew(() =>
25. {
26.     Stopwatch sw = Stopwatch.StartNew();
27.     while (true)
28.     {
29.         Thread.Sleep(5000);
30.         double speed = num / sw.Elapsed.TotalSeconds;
31.         Console.WriteLine($"10000个循环干活总速度={speed:#### ####.0} 次/秒");
32.     }
33. }, TaskCreationOptions.LongRunning);
35. Console.WriteLine("开始");
36. Console.ReadLine();
37. myTimer.Dispose();
39. class MyTimer : IDisposable
40. {
41.     private int _interval;
42.     private Thread _thread;
43.     private bool _threadRunning = false;
44.     private ConcurrentQueue<MyAwaiter> _queue;
46.     /// <summary>
47.     /// Timer
48.     /// </summary>
49.     /// <param name="interval">时间间隔</param>
50.     /// <param name="parallelCount">并行数量</param>
51.     public MyTimer(int interval, int parallelCount)
52.     {
53.         _interval = interval;
54.         _queue = new ConcurrentQueue<MyAwaiter>();
55.         _threadRunning = true;
57.         _thread = new Thread(() =>
58.         {
59.             while (_threadRunning)
60.             {
61.                 for (int i = 0; i < parallelCount; i++)
62.                 {
63.                     if (_queue.TryDequeue(out MyAwaiter myAwaiter))
64.                     {
65.                         myAwaiter.Run();
66.                     }
67.                 }
69.                 Thread.Sleep(_interval);
70.             }
71.         });
72.         _thread.Start();
73.     }
75.     public MyAwaiter Delay()
76.     {
77.         MyAwaiter awaiter = new MyAwaiter(this);
78.         _queue.Enqueue(awaiter);
79.         return awaiter;
80.     }
82.     public void Dispose()
83.     {
84.         _threadRunning = false;
85.     }
86. }
88. class MyAwaiter : INotifyCompletion
89. {
90.     private MyTimer _timer;
92.     private Action _continuation;
94.     public bool IsCompleted { get; private set; }
96.     public MyAwaiter(MyTimer timer)
97.     {
98.         _timer = timer;
99.     }
101.     public void OnCompleted(Action continuation)
102.     {
103.         _continuation = continuation;
104.     }
106.     public void Run()
107.     {
108.         IsCompleted = true;
109.         _continuation?.Invoke();
110.     }
112.     public MyAwaiter GetAwaiter()
113.     {
114.         return this;
115.     }
117.     public object GetResult()
118.     {
119.         return null;
120.     }
122. }

复制代码

时间轮算法有点难写，我还没有掌握，换了一种写法，达到了题主的要求，速度可以达到50多万次/秒，CPU占用3%。但有缺点，MyTimer用完需要Dispose，有个并行度参数parallelCount需要根据测试代码中for循环次数设置，设置为for循环次数的1.7倍，这个参数很讨厌，再一个就是Delay时间设置了15毫秒，但是不精确，实际任务延迟可能会超出15毫秒，或者小于15毫秒，当然这里假设计时器是精确的，实际上计时器误差可能到达10毫秒，这里认为它是精确无误差的，在这个前提下，任务执行间隔不精确，但比上次尝试，最大延迟500毫秒应该要好很多。
本人水平有限，写的匆忙，但我感觉这个问题还是很重要的。问题简单来说就是大量Task.Delay会导致性能问题，有没有更高效的Delay实现？
这个问题有什么实际价值？看我另一个回答：求助多线程读取大量PLC问题？
我给的回答：

1. for (int i = 0; i < 500; i++)
2. {
3.     ReadPLC(i);
4. }
6. async void ReadPLC(int plcIndex)
7. {
8.     while (true)
9.     {
10.         // todo: 读取PLC
11.         Console.WriteLine($"读取PLC {plcIndex}");
13.         await Task.Delay(200);
14.     }
15. }

复制代码

还好它这只要求500个plc，间隔200毫秒也比较长，用Task.Delay完全可以，如果是1万个plc呢？如果要求Delay(15)，就不能像我这样写了。但是，你看看，这样写有多么简单？！本来一个多线程并行问题，写起来很复杂，很容易写出bug，如果能像同步代码这样写，写出来性能不亚于多线程并行，逻辑简单，不容易出bug。
注意，和时间轮算法所面对的需求可能并不一样，这里是为了实现高性能的Delay，而不是为了实现简化版的Quartz。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！