前言
今天分享一下日常工作中遇到的性能問題和解決方案，比較零碎，后續會持續更新（運行環境為.net core 3.1）
本次分享的案例都是由實際生產而來，經過簡化后作為舉例
Part 1（作為簡單數據載體時class和struct的性能對比）
關於class和struct的區別，根據經驗，在實際開發的絕大多數場景，都會使用class作為數據類型，但是如果是作為簡單數據的超大集合的類型，並且不涉及到拷貝、傳參等其他操作的時候，可以考慮使用struct，因為相對於引用類型的class分配在堆上，作為值類型的struct是分配在棧上的，這樣就擁有了更快的創建速度和節約了指針的空間，列舉了3000萬個元素的集合分別以class和struct作為類型，做如下測試（測試工具為vs自帶的 Diagnostic Tools）：
class Program {
static void Main (string[] args) {
var structs = new List<StructTest> ();
var stopwatch1 = new Stopwatch ();
stopwatch1.Start ();
for (int i = 0; i < 30000000; i++) {
structs.Add (new StructTest { Id = i, Value = i });
}
stopwatch1.Stop ();
var structsTotalMemory = GC.GetTotalMemory (true);
Console.WriteLine ($"使用結構體時消耗內存：{structsTotalMemory}字節，耗時：{stopwatch1.ElapsedMilliseconds}毫秒");
Console.ReadLine ();
}
public struct StructTest {
public int Id { get; set; }
public int Value { get; set; }
}
}
class Program {
static void Main (string[] args) {
var classes = new List<ClassTest> ();
var stopwatch2 = new Stopwatch ();
stopwatch2.Start ();
for (int i = 0; i < 30000000; i++) {
classes.Add (new ClassTest { Id = i, Value = i });
}
stopwatch2.Stop ();
var classesTotalMemory = GC.GetTotalMemory (true);
Console.WriteLine ($"使用類時消耗內存：{classesTotalMemory}字節，耗時：{ stopwatch2.ElapsedMilliseconds}毫秒");
Console.ReadLine ();
}
public struct StructTest {
public int Id { get; set; }
public int Value { get; set; }
}
}
通過計算，struct的空間消耗包含了：每個結構體包含兩個存放在棧上的整型，每個整型占4個字節，每個結構體占8字節，乘以3000萬個元素共計占用240,000,000字節， 跟實際測量值大體吻合；
而class的空間消耗較為復雜，包含了：每個類包含兩個存在堆上的整型，每個整型占4字節，兩個存在棧上的指針，因為是64位計算機所以每個指針占8字節，再加上類自身的指針8字節，每個類占24字節(4+4+8+8+8)，乘以3000萬個元素共計占用960,000,000字節，跟實際測量值大體吻合。時間消耗方面class因為存在內存分配，耗時5秒左右，遠大於struct的1.5秒。
更多關於class和struct的關系和區別請移步微軟官方文檔 https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/choosing-between-class-and-struct
Part 2（集合嵌套遍歷的優化）
關於嵌套集合遍歷，我們以兩層集合嵌套遍歷，每個集合存放10000個亂序的整型，然后統計同時存在兩個集合的元素個數，從上到下分別以常規嵌套循環，使用HashSet類型，參考PostgreSQL的MergeJoin思路舉例：
class Program {
static void Main (string[] args) {
var l1s = new List<int> ();
var l2s = new List<int> ();
var rd = new Random ();
for (int i = 0; i < 10000; i++) {
l1s.Add (rd.Next (1, 10000));
l2s.Add (rd.Next (1, 10000));
}
var sw = new Stopwatch ();
sw.Start ();
var r = new HashSet<int> ();
foreach (var l1 in l1s) {
foreach (var l2 in l2s) {
if (l1 == l2) {
r.Add (l1);
}
}
}
sw.Stop ();
Console.WriteLine ($"共找到{r.Count}個元素同時存在於l1s和l2s，共計耗時{sw.ElapsedMilliseconds}毫秒");
Console.ReadLine ();
}
class Program {
static void Main (string[] args) {
var l1s = new HashSet<int> ();
var l2s = new HashSet<int> ();
var rd = new Random ();
while (l1s.Count < 10000)
l1s.Add (rd.Next (1, 100000));
while (l2s.Count < 10000)
l2s.Add (rd.Next (1, 100000));
var sw = new Stopwatch ();
sw.Start ();
var r = new List<int> ();
foreach (var l1 in l1s) {
if (l2s.Contains (l1)) {
r.Add (l1);
}
}
sw.Stop ();
Console.WriteLine ($"共找到{r.Count}個元素同時存在於l1s和l2s，共計耗時{sw.ElapsedMilliseconds}毫秒");
Console.ReadLine ();
}
class Program {
static void Main (string[] args) {
var l1s = new List<int> ();
var l2s = new List<int> ();
var rd = new Random ();
for (int i = 0; i < 10000; i++) {
l1s.Add (rd.Next (1, 10000));
l2s.Add (rd.Next (1, 10000));
}
var sw = new Stopwatch ();
sw.Start ();
var r = new List<int> ();
l1s = l1s.OrderBy (x => x).ToList ();
l2s = l2s.OrderBy (x => x).ToList ();
var l1index = 0;
var l2index = 0;
for (int i = 0; i < 10000; i++) {
var l1v = l1s[l1index];
var l2v = l2s[l2index];
if (l1v == l2v) {
r.Add (l1v);
l1index++;
l2index++;
}
if (l1v > l2v && l2index < 10000)
l2index++;
if (l1v < l2v && l1index < 10000)
l1index++;
if (l1index == 9999 && l2index == 9999)
break;
}
sw.Stop ();
Console.WriteLine ($"共找到{r.Count}個元素同時存在於l1和l2s，共計耗時{sw.ElapsedMilliseconds}毫秒");
Console.ReadLine ();
}
由結果可見，常規嵌套遍歷耗時1秒，時間復雜度為O(n2)；使用HashSet耗時3毫秒，HashSet底層使用了哈希表，通過循環外層集合，對內層集合直接進行hash查找，時間復雜度為O(n)； 參考PostgreSQL的MergeJoin思路實現耗時19毫秒，方法為先對集合進行排序，再標記當前位移，利用數組可以下標直接取值的特性取值后對比，時間復雜度為O(n)。由此可見，對於數據量較大的集合，嵌套循環要尤為重視起來。
更多關於merge join的設計思路請移步PostgreSQL的官方文檔 https://www.postgresql.org/docs/12/planner-optimizer.html
要注意的是，無論是使用哈希表還是排序，都會引入額外的損耗，畢竟在計算機的世界里，要么以時間換空間，要么以空間換時間，如果想同時優化時間或空間可以辦到嗎？在某些場景上也是有可能的，可以參考我之前的博文，通過內存映射文件結合今天講的內容，結合具體業務場景嘗試一下。
如有任何問題，歡迎大家隨時指正，分享和試錯也是個學習的過程，謝謝大家~