大家好!今天我想和大家分享几个 .NET 的性能小贴士与基准测试。

我的系统环境:

  • BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19042.985
  • Intel Core i7-9750H CPU 2.60GHz, 1 CPU, 12 logical and 6 physical cores
  • .NET SDK=5.0.104

我将以百分比的形式提供基准测试结果,其中 100% 是最快的结果。

1. 用 StringBuilder 拼接字符串

我们知道,字符串 string 是不可变的。因此,每当你拼接字符串时,就会分配一个新的字符串对象,并填充内容,最终被回收。所有这些都有昂贵开销,这就是为什么 StringBuilder 在字符串拼接时总有更好的性能。

基准测试例子:

  1. private static StringBuilder sb = new();
  2. [Benchmark]
  3. public void Concat3() => ExecuteConcat(3);
  4. [Benchmark]
  5. public void Concat5() => ExecuteConcat(5);
  6. [Benchmark]
  7. public void Concat10() => ExecuteConcat(10);
  8. [Benchmark]
  9. public void Concat100() => ExecuteConcat(100);
  10. [Benchmark]
  11. public void Concat1000() => ExecuteConcat(1000);
  12. [Benchmark]
  13. public void Builder3() => ExecuteBuilder(3);
  14. [Benchmark]
  15. public void Builder5() => ExecuteBuilder(5);
  16. [Benchmark]
  17. public void Builder10() => ExecuteBuilder(10);
  18. [Benchmark]
  19. public void Builder100() => ExecuteBuilder(100);
  20. [Benchmark]
  21. public void Builder1000() => ExecuteBuilder(1000);
  22. public void ExecuteConcat(int size)
  23. {
  24. string s = "";
  25. for (int i = 0; i < size; i++)
  26. {
  27. s += "a";
  28. }
  29. }
  30. public void ExecuteBuilder(int size)
  31. {
  32. sb.Clear();
  33. for (int i = 0; i < size; i++)
  34. {
  35. sb.Append("a");
  36. }
  37. }

结果:

  1. 1. 3 string concatenations - 218% (35.21 ns)
  2. 2. 3 StringBuilder concatenations - 100% (16.09 ns)
  3. 1. 5 string concatenations - 277% (66.99 ns)
  4. 2. 5 StringBuilder concatenations - 100% (24.16 ns)
  5. 1. 10 string concatenations - 379% (160.69 ns)
  6. 2. 10 StringBuilder concatenations - 100% (42.37 ns)
  7. 1. 100 string concatenations - 711% (2,796.63 ns)
  8. 2. 100 StringBuilder concatenations - 100% (393.12 ns)
  9. 1. 1000 string concatenations - 3800% (144,100.46 ns)
  10. 2. 1000 StringBuilder concatenations - 100% (3,812.22 ns)

2. 赋予动态集合初始大小

.NET 提供了很多集合类型,比如 List<T>, Dictionary<T>, 和 HashSet<T>。所有这些集合都有动态的容量,当你添加更多的项目时,它们的大小会自动扩大。

当集合达到其大小限制时,它将分配一个新的更大的内存缓冲区,这意味着要进行额外的开销去分配容量。

基准测试例子:

  1. [Benchmark]
  2. public void ListDynamicCapacity()
  3. {
  4. List<int> list = new List<int>();
  5. for (int i = 0; i < Size; i++)
  6. {
  7. list.Add(i);
  8. }
  9. }
  10. [Benchmark]
  11. public void ListPlannedCapacity()
  12. {
  13. List<int> list = new List<int>(Size);
  14. for (int i = 0; i < Size; i++)
  15. {
  16. list.Add(i);
  17. }
  18. }

在第一个方法中,List 集合使用默认容量初始化,并动态扩大。在第二个方法中,初始容量被设置为它所需要的固定大小。

对于 1000 个项目,其结果是:

  1. 1. List Dynamic Capacity - 140% (2.490 us)
  2. 2. List Planned Capacity - 100% (1.774 us)

DictionaryHashSet 的测试结果是:

  1. 1. Dictionary Dynamic Capacity - 233% (20.314 us)
  2. 2. Dictionary Planned Capacity - 100% (8.702 us)
  3. 1. HashSet Dynamic Capacity - 223% (17.004 us)
  4. 2. HashSet Planned Capacity - 100% (7.624 us)

3. ArrayPool 用于短时大数组

数组的分配和回收的开销可能是相当昂贵的,高频地执行这些分配会增加 GC 的压力并损害性能。一个优雅的解决方案使用是 System.Buffers.ArrayPool 类,它可以在 NuGet 的 Systems.Buffers 中找到。

这个思想和 ThreadPool 很相似。为数组分配一个共享缓冲区,你可以重复使用,而不需要实际分配和回收它们占用的内存。基本用法是调用 ArrayPool<T>.Shared.Rent(size),这将返回一个常规数组,你可以以任何方式使用它。完成后,调用 ArrayPool<int>.Shared.Return(array) 将缓冲区返回到共享池中。

基准测试例子:

  1. [Benchmark]
  2. public void RegularArray()
  3. {
  4. int[] array = new int[ArraySize];
  5. }
  6. [Benchmark]
  7. public void SharedArrayPool()
  8. {
  9. var pool = ArrayPool<int>.Shared;
  10. int[] array = pool.Rent(ArraySize);
  11. pool.Return(array);
  12. }

ArraySize = 1000 的结果:

  1. 1. Regular Array - 2270% (440.41 ns)
  2. 2. Shared ArrayPool - 100% (19.40 ns)

4. 结构代替类

当涉及到对象回收时,Struct 有如下几个好处:

  • 当结构类型不是类的一部分时,它们被分配在堆栈中,根本不需要垃圾回收。
  • 当结构是类(或任何引用类型)的一部分时,它们被存储在堆中。在这种情况下,它们是内联存储的,并且会随包含类型回收而回收。内联意味着该结构的数据是按原样存储的,这与引用类型相反,在引用类型中,指针被存储到堆上另一个位置。所以回收的成本要低很多。
  • 结构比引用类型占用的内存更少,因为它们没有 ObjectHeaderMethodTable

基准测试例子:

  1. class VectorClass
  2. {
  3. public int X { get; set; }
  4. public int Y { get; set; }
  5. }
  6. struct VectorStruct
  7. {
  8. public int X { get; set; }
  9. public int Y { get; set; }
  10. }
  11. private const int ITEMS = 10000;
  12. [Benchmark]
  13. public void WithClass()
  14. {
  15. VectorClass[] vectors = new VectorClass[ITEMS];
  16. for (int i = 0; i < ITEMS; i++)
  17. {
  18. vectors[i] = new VectorClass();
  19. vectors[i].X = 5;
  20. vectors[i].Y = 10;
  21. }
  22. }
  23. [Benchmark]
  24. public void WithStruct()
  25. {
  26. VectorStruct[] vectors = new VectorStruct[ITEMS];
  27. // At this point all the vectors instances are already allocated with default values
  28. for (int i = 0; i < ITEMS; i++)
  29. {
  30. vectors[i].X = 5;
  31. vectors[i].Y = 10;
  32. }
  33. }

结果:

  1. 1. With Class - 742% (88.83 us)
  2. 2. With Struct - 100% (11.97 us)

5. ConcurrentQueue 代替 ConcurrentBag

在没有基准测试的情况下,不要使用 ConcurrentBag<T>。这个集合是为非常特殊的使用场景而设计的(当经常有项目被排队的线程删除时)。如果需要一个并发的集合队列,请选择 ConcurrentQueue<T>

基准测试例子:

  1. private static int Size = 1000;
  2. [Benchmark]
  3. public void Bag()
  4. {
  5. ConcurrentBag<int> bag = new();
  6. for (int i = 0; i < Size; i++)
  7. {
  8. bag.Add(i);
  9. }
  10. }
  11. [Benchmark]
  12. public void Queue()
  13. {
  14. ConcurrentQueue<int> bag = new();
  15. for (int i = 0; i < Size; i++)
  16. {
  17. bag.Enqueue(i);
  18. }
  19. }

结果:

  1. 1. ConcurrentBag - 165% (24.21 us)
  2. 2. ConcurrentQueue - 100% (14.64 us)