日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
.NET陷阱之奇怪的OutOfMemoryException

我們在開發(fā)過程中曾經(jīng)遇到過一個奇怪的問題：當軟件加載了很多比較大規(guī)模的數(shù)據(jù)后，會偶爾出現(xiàn)OutOfMemoryException異常，但通過內(nèi)存檢查工具卻發(fā)現(xiàn)還有很多可用內(nèi)存。于是我們懷疑是可用內(nèi)存總量充足，但卻沒有足夠的連續(xù)內(nèi)存了——也就是說存在很多未分配的內(nèi)存空隙。但不是說.NET運行時的垃圾收集器會壓縮使用中的內(nèi)存，從而使已經(jīng)釋放的內(nèi)存空隙連成一片嗎？于是我深入研究了一下垃圾回收相關的內(nèi)容，最終明確的了問題所在——大對象堆（LOH）的使用。如果你也遇到過類似的問題或者對相關的細節(jié)有興趣的話，就繼續(xù)讀讀吧。

成都創(chuàng)新互聯(lián)公司是一家專注于做網(wǎng)站、成都做網(wǎng)站與策劃設計,南陽網(wǎng)站建設哪家好?成都創(chuàng)新互聯(lián)公司做網(wǎng)站,專注于網(wǎng)站建設十載,網(wǎng)設計領域的專業(yè)建站公司;建站業(yè)務涵蓋:南陽等地區(qū)。南陽做網(wǎng)站價格咨詢:18980820575

如果沒有特殊說明，后面的敘述都是針對32位系統(tǒng)。

首先我們來探討另外一個問題：不考慮非托管內(nèi)存的使用，在最壞情況下，當系統(tǒng)出現(xiàn)OutOfMemoryException異常時，有效的內(nèi)存（程序中有GC Root的對象所占用的內(nèi)存）使用量會是多大呢？2G？ 1G？ 500M？ 50M？或者更小（是不是以為我在開玩笑）？來看下面這段代碼（參考 https://www.simple-talk.com/dotnet/.net-framework/the-dangers-of-the-large-object-heap/）。

 
 
 
 
    
  
  
  
  
  1. public class Program  
    2. 
  
  
  
  
  2.  {  
    3. 
  
  
  
  
  3.      static void Main(string[] args)  
    4. 
  
  
  
  
  4.      {  
    5. 
  
  
  
  
  5.          var smallBlockSize = 90000;  
    6. 
  
  
  
  
  6.          var largeBlockSize = 1 << 24;  
    7. 
  
  
  
  
  7.          var count = 0;  
    8. 
  
  
  
  
  8.          var bigBlock = new byte[0];  
    9. 
  
  
  
  
  9.          try 
    10. 
  
  
  
  
  10.          {  
    11. 
  
  
  
  
  11.              var smallBlocks = new List();  
    12. 
  
  
  
  
  12.              while (true)  
    13. 
  
  
  
  
  13.              {  
    14. 
  
  
  
  
  14.                  GC.Collect();  
    15. 
  
  
  
  
  15.                  bigBlock = new byte[largeBlockSize];  
    16. 
  
  
  
  
  16.                  largeBlockSize++;  
    17. 
  
  
  
  
  17.                  smallBlocks.Add(new byte[smallBlockSize]);  
    18. 
  
  
  
  
  18.                  count++;  
    19. 
  
  
  
  
  19.              }  
    20. 
  
  
  
  
  20.          }  
    21. 
  
  
  
  
  21.          catch (OutOfMemoryException)  
    22. 
  
  
  
  
  22.          {  
    23. 
  
  
  
  
  23.              bigBlock = null;  
    24. 
  
  
  
  
  24.              GC.Collect();  
    25. 
  
  
  
  
  25.              Console.WriteLine("{0} Mb allocated",   
    26. 
  
  
  
  
  26.                  (count * smallBlockSize) / (1024 * 1024));  
    27. 
  
  
  
  
  27.          }  
    28. 
  
  
  
  
  28.            
    29. 
  
  
  
  
  29.          Console.ReadLine();  
    30. 
  
  
  
  
  30.      }  
    31. 
  
  
  
  
  31.  } 
    32.

這段代碼不斷的交替分配一個較小的數(shù)組和一個較大的數(shù)組，其中較小數(shù)組的大小為90, 000字節(jié)，而較大數(shù)組的大小從16M字節(jié)開始，每次增加一個字節(jié)。如代碼第15行所示，在每一次循環(huán)中bigBlock都會引用新分配的大數(shù)組，從而使之前的大數(shù)組變成可以被垃圾回收的對象。在發(fā)生OutOfMemoryException時，實際上代碼會有count個小數(shù)組和一個大小為 16M + count 的大數(shù)組處于有效狀態(tài)。最后代碼輸出了異常發(fā)生時小數(shù)組所占用的內(nèi)存總量。

下面是在我的機器上的運行結(jié)果——和你的預測有多大差別？提醒一下，如果你要親自測試這段代碼，而你的機器是64位的話，一定要把生成目標改為x86。

 
 
 
 
    
  
  
  
  
  1. 23 Mb allocated 
    2.

考慮到32位程序有2G的可用內(nèi)存，這里實現(xiàn)的使用率只有1%！

下面即介紹個中原因。需要說明的是，我只是想以最簡單的方式闡明問題，所以有些語言可能并不精確，可以參考http://msdn.microsoft.com/en-us/magazine/cc534993.aspx以獲得更詳細的說明。

.NET的垃圾回收機制基于“Generation”的概念，并且一共有G0, G1, G2三個Generation。一般情況下，每個新創(chuàng)建的對象都屬于于G0，對象每經(jīng)歷一次垃圾回收過程而未被回收時，就會進入下一個Generation（G0 -> G1 -> G2），但如果對象已經(jīng)處于G2，則它仍然會處于G2中。

軟件開始運行時，運行時會為每一個Generation預留一塊連續(xù)的內(nèi)存（這樣說并不嚴格，但不影響此問題的描述），同時會保持一個指向此內(nèi)存區(qū)域中尚未使用部分的指針P，當需要為對象分配空間時，直接返回P所在的地址，并將P做相應的調(diào)整即可，如下圖所示?！卷槺阏f一句，也正是因為這一技術，在.NET中創(chuàng)建一個對象要比在C或C++的堆中創(chuàng)建對象要快很多——當然，是在后者不使用額外的內(nèi)存管理模塊的情況下。】

在對某個Generation進行垃圾回收時，運行時會先標記所有可以從有效引用到達的對象，然后壓縮內(nèi)存空間，將有效對象集中到一起，而合并已回收的對象占用的空間，如下圖所示。

但是，問題就出在上面特別標出的“一般情況”之外。.NET會將對象分成兩種情況區(qū)別對象，一種是大小小于85, 000字節(jié)的對象，稱之為小對象，它就對應于前面描述的一般情況；另外一種是大小在85, 000之上的對象，稱之為大對象，就是它造成了前面示例代碼中內(nèi)存使用率的問題。在.NET中，所有大對象都是分配在另外一個特別的連續(xù)內(nèi)存（LOH, Large Object Heap）中的，而且，每個大對象在創(chuàng)建時即屬于G2，也就是說只有在進行Generation 2的垃圾回收時，才會處理LOH。而且在對LOH進行垃圾回收時不會壓縮內(nèi)存！更進一步，LOH上空間的使用方式也很特殊——當分配一個大對象時，運行時會優(yōu)先嘗試在LOH的尾部進行分配，如果尾部空間不足，就會嘗試向操作系統(tǒng)請求更多的內(nèi)存空間，只有在這一步也失敗時，才會重新搜索之前無效對象留下的內(nèi)存空隙。如下圖所示：

從上到下看

1.LOH中已經(jīng)存在一個大小為85K的對象和一個大小為16M對象，當需要分配另外一個大小為85K的對象時，會在尾部分配空間；

2.此時發(fā)生了一次垃圾回收，大小為16M的對象被回收，其占用的空間為未使用狀態(tài)，但運行時并沒有對LOH進行壓縮；

3.此時再分配一個大小為16.1M的對象時，分嘗試在LOH尾部分配，但尾部空間不足。所以，

4.運行時向操作系統(tǒng)請求額外的內(nèi)存，并將對象分配在尾部；

5.此時如果再需要分配一個大小為85K的對象，則優(yōu)先使用尾部的空間。

所以前面的示例代碼會造成LOH變成下面這個樣子，當最后要分配16M + N的內(nèi)存時，因為前面已經(jīng)沒有任何一塊連續(xù)區(qū)域滿足要求時，所以就會引發(fā)OutOfMemoryExceptiojn異常。

要解決這一問題其實并不容易，但可以考慮下面的策略。 

#p#

1.將比較大的對象分割成較小的對象，使每個小對象大小小于85, 000字節(jié)，從而不再分配在LOH上；

2.盡量“重用”少量的大對象，而不是分配很多大對象；

3.每隔一段時間就重啟一下程序。

最終我們發(fā)現(xiàn)，我們的軟件中使用數(shù)組（List）保存了一些曲線數(shù)據(jù)，而這些曲線的大小很可能會超過了85, 000字節(jié)，同時曲線對象的個數(shù)也非常多，從而對LOH造成了很大的壓力，甚至出現(xiàn)了文章開頭所描述的情況。針對這一情況，我們采用了策略1的方法，定義了一個類似C++中deque的數(shù)據(jù)結(jié)構(gòu)，它以分塊內(nèi)存的方式存儲數(shù)據(jù)，而且保證每一塊的大小都小于85, 000，從而解決了這一問題。

此外要說的是，不要以為64位環(huán)境中可以忽略這一問題。雖然64位環(huán)境下有更大的內(nèi)存空間，但對于操作系統(tǒng)來說，.NET中的LOH會提交很大范圍的內(nèi)存區(qū)域，所以當存在大量的內(nèi)存空隙時，即使不會出現(xiàn)OutOfMemoryException異常，也會使得內(nèi)頁頁面交換的頻率不斷上升，從而使軟件運行的越來越慢。

最后分享我們定義的分塊列表，它對IList接口的實現(xiàn)行為與List相同，代碼中只給出了比較重要的幾個方法。

 
 
 
 
    
  
  
  
  
  1. public class BlockList : IList  
    2. 
  
  
  
  
  2.  {  
    3. 
  
  
  
  
  3.      private static int maxAllocSize;  
    4. 
  
  
  
  
  4.      private static int initAllocSize;  
    5. 
  
  
  
  
  5.      private T[][] blocks;  
    6. 
  
  
  
  
  6.      private int blockCount;  
    7. 
  
  
  
  
  7.      private int[] blockSizes;  
    8. 
  
  
  
  
  8.      private int version;  
    9. 
  
  
  
  
  9.      private int countCache;  
    10. 
  
  
  
  
  10.      private int countCacheVersion;  
    11. 
  
  
  
  
  11.    
    12. 
  
  
  
  
  12.      static BlockList()  
    13. 
  
  
  
  
  13.      {  
    14. 
  
  
  
  
  14.          var type = typeof(T);  
    15. 
  
  
  
  
  15.          var size = type.IsValueType ? Marshal.SizeOf(default(T)) : IntPtr.Size;  
    16. 
  
  
  
  
  16.          maxAllocSize = 80000 / size;  
    17. 
  
  
  
  
  17.          initAllocSize = 8;  
    18. 
  
  
  
  
  18.      }  
    19. 
  
  
  
  
  19.    
    20. 
  
  
  
  
  20.      public BlockList()  
    21. 
  
  
  
  
  21.      {  
    22. 
  
  
  
  
  22.          blocks = new T[8][];  
    23. 
  
  
  
  
  23.          blockSizes = new int[8];  
    24. 
  
  
  
  
  24.          blockCount = 0;  
    25. 
  
  
  
  
  25.      }  
    26. 
  
  
  
  
  26.    
    27. 
  
  
  
  
  27.      public void Add(T item)  
    28. 
  
  
  
  
  28.      {  
    29. 
  
  
  
  
  29.          int blockId = 0, blockSize = 0;  
    30. 
  
  
  
  
  30.          if (blockCount == 0)  
    31. 
  
  
  
  
  31.          {  
    32. 
  
  
  
  
  32.              UseNewBlock();  
    33. 
  
  
  
  
  33.          }  
    34. 
  
  
  
  
  34.          else 
    35. 
  
  
  
  
  35.          {  
    36. 
  
  
  
  
  36.              blockId = blockCount - 1;  
    37. 
  
  
  
  
  37.              blockSize = blockSizes[blockId];  
    38. 
  
  
  
  
  38.              if (blockSize == blocks[blockId].Length)  
    39. 
  
  
  
  
  39.              {  
    40. 
  
  
  
  
  40.                  if (!ExpandBlock(blockId))  
    41. 
  
  
  
  
  41.                  {  
    42. 
  
  
  
  
  42.                      UseNewBlock();  
    43. 
  
  
  
  
  43.                      ++blockId;  
    44. 
  
  
  
  
  44.                      blockSize = 0;  
    45. 
  
  
  
  
  45.                  }  
    46. 
  
  
  
  
  46.              }  
    47. 
  
  
  
  
  47.          }  
    48. 
  
  
  
  
  48.    
    49. 
  
  
  
  
  49.          blocks[blockId][blockSize] = item;  
    50. 
  
  
  
  
  50.          ++blockSizes[blockId];  
    51. 
  
  
  
  
  51.          ++version;  
    52. 
  
  
  
  
  52.      }  
    53. 
  
  
  
  
  53.    
    54. 
  
  
  
  
  54.      public void Insert(int index, T item)  
    55. 
  
  
  
  
  55.      {  
    56. 
  
  
  
  
  56.          if (index > Count)  
    57. 
  
  
  
  
  57.          {  
    58. 
  
  
  
  
  58.              throw new ArgumentOutOfRangeException("index");  
    59. 
  
  
  
  
  59.          }  
    60. 
  
  
  
  
  60.    
    61. 
  
  
  
  
  61.          if (blockCount == 0)  
    62. 
  
  
  
  
  62.          {  
    63. 
  
  
  
  
  63.              UseNewBlock();  
    64. 
  
  
  
  
  64.              blocks[0][0] = item;  
    65. 
  
  
  
  
  65.              blockSizes[0] = 1;  
    66. 
  
  
  
  
  66.              ++version;  
    67. 
  
  
  
  
  67.              return;  
    68. 
  
  
  
  
  68.          }  
    69. 
  
  
  
  
  69.    
    70. 
  
  
  
  
  70.          for (int i = 0; i < blockCount; ++i)  
    71. 
  
  
  
  
  71.          {  
    72. 
  
  
  
  
  72.              if (index >= blockSizes[i])  
    73. 
  
  
  
  
  73.              {  
    74. 
  
  
  
  
  74.                  index -= blockSizes[i];  
    75. 
  
  
  
  
  75.                  continue;  
    76. 
  
  
  
  
  76.              }  
    77. 
  
  
  
  
  77.    
    78. 
  
  
  
  
  78.              if (blockSizes[i] < blocks[i].Length || ExpandBlock(i))  
    79. 
  
  
  
  
  79.              {  
    80. 
  
  
  
  
  80.                  for (var j = blockSizes[i]; j > index; --j)  
    81. 
  
  
  
  
  81.                  {  
    82. 
  
  
  
  
  82.                      blocks[i][j] = blocks[i][j - 1];  
    83. 
  
  
  
  
  83.                  }  
    84. 
  
  
  
  
  84.    
    85. 
  
  
  
  
  85.                  blocks[i][index] = item;  
    86. 
  
  
  
  
  86.                  ++blockSizes[i];  
    87. 
  
  
  
  
  87.                  break;  
    88. 
  
  
  
  
  88.              }  
    89. 
  
  
  
  
  89.    
    90. 
  
  
  
  
  90.              if (i == blockCount - 1)  
    91. 
  
  
  
  
  91.              {  
    92. 
  
  
  
  
  92.                  UseNewBlock();  
    93. 
  
  
  
  
  93.              }  
    94. 
  
  
  
  
  94.    
    95. 
  
  
  
  
  95.              if (blockSizes[i + 1] == blocks[i + 1].Length  
    96. 
  
  
  
  
  96.                  && !ExpandBlock(i + 1))  
    97. 
  
  
  
  
  97.              {  
    98. 
  
  
  
  
  98.                  UseNewBlock();  
    99. 
  
  
  
  
  99.                  var newBlock = blocks[blockCount - 1];  
    100. 
  
  
  
  
  100.                  for (int j = blockCount - 1; j > i + 1; --j)  
    101. 
  
  
  
  
  101.                  {  
    102. 
  
  
  
  
  102.                      blocks[j] = blocks[j - 1];  
    103. 
  
  
  
  
  103.                      blockSizes[j] = blockSizes[j - 1];  
    104. 
  
  
  
  
  104.                  }  
    105. 
  
  
  
  
  105.    
    106. 
  
  
  
  
  106.                  blocks[i + 1] = newBlock;  
    107. 
  
  
  
  
  107.                  blockSizes[i + 1] = 0;  
    108. 
  
  
  
  
  108.              }  
    109. 
  
  
  
  
  109.    
    110. 
  
  
  
  
  110.              var nextBlock = blocks[i + 1];  
    111. 
  
  
  
  
  111.              var nextBlockSize = blockSizes[i + 1];  
    112. 
  
  
  
  
  112.              for (var j = nextBlockSize; j > 0; --j)  
    113. 
  
  
  
  
  113.              {  
    114. 
  
  
  
  
  114.                  nextBlock[j] = nextBlock[j - 1];  
    115. 
  
  
  
  
  115.              }  
    116. 
  
  
  
  
  116.    
    117. 
  
  
  
  
  117.              nextBlock[0] = blocks[i][blockSizes[i] - 1];  
    118. 
  
  
  
  
  118.              ++blockSizes[i + 1];  
    119. 
  
  
  
  
  119.    
    120. 
  
  
  
  
  120.              for (var j = blockSizes[i] - 1; j > index; --j)  
    121. 
  
  
  
  
  121.              {  
    122. 
  
  
  
  
  122.                  blocks[i][j] = blocks[i][j - 1];  
    123. 
  
  
  
  
  123.              }  
    124. 
  
  
  
  
  124.    
    125. 
  
  
  
  
  125.              blocks[i][index] = item;  
    126. 
  
  
  
  
  126.              break;  
    127. 
  
  
  
  
  127.          }  
    128. 
  
  
  
  
  128.    
    129. 
  
  
  
  
  129.          ++version;  
    130. 
  
  
  
  
  130.      }  
    131. 
  
  
  
  
  131.    
    132. 
  
  
  
  
  132.      public void RemoveAt(int index)  
    133. 
  
  
  
  
  133.      {  
    134. 
  
  
  
  
  134.          if (index < 0 || index >= Count)  
    135. 
  
  
  
  
  135.          {  
    136. 
  
  
  
  
  136.              throw new ArgumentOutOfRangeException("index");  
    137. 
  
  
  
  
  137.          }  
    138. 
  
  
  
  
  138.    
    139. 
  
  
  
  
  139.          for (int i = 0; i < blockCount; ++i)  
    140. 
  
  
  
  
  140.          {  
    141. 
  
  
  
  
  141.              if (index >= blockSizes[i])  
    142. 
  
  
  
  
  142.              {  
    143. 
  
  
  
  
  143.                  index -= blockSizes[i];  
    144. 
  
  
  
  
  144.                  continue;  
    145. 
  
  
  
  
  145.              }  
    146. 
  
  
  
  
  146.    
    147. 
  
  
  
  
  147.              if (blockSizes[i] == 1)  
    148. 
  
  
  
  
  148.              {  
    149. 
  
  
  
  
  149.                  for (int j = i + 1; j < blockCount; ++j)  
    150. 
  
  
  
  
  150.                  {  
    151. 
  
  
  
  
  151.                      blocks[j - 1] = blocks[j];  
    152. 
  
  
  
  
  152.                      blockSizes[j - 1] = blockSizes[j];  
    153. 
  
  
  
  
  153.                  }  
    154. 
  
  
  
  
  154.    
    155. 
  
  
  
  
  155.                  blocks[blockCount - 1] = null;  
    156. 
  
  
  
  
  156.                  blockSizes[blockCount - 1] = 0;  
    157. 
  
  
  
  
  157.                  --blockCount;  
    158. 
  
  
  
  
  158.              }  
    159. 
  
  
  
  
  159.              else 
    160. 
  
  
  
  
  160.              {  
    161. 
  
  
  
  
  161.                  for (int j = index + 1; j < blockSizes[i]; ++j)  
    162. 
  
  
  
  
  162.                  {  
    163. 
  
  
  
  
  163.                      blocks[i][j - 1] = blocks[i][j];  
    164. 
  
  
  
  
  164.                  }  
    165. 
  
  
  
  
  165.    
    166. 
  
  
  
  
  166.                  blocks[i][blockSizes[i] - 1] = default(T);  
    167. 
  
  
  
  
  167.                  --blockSizes[i];  
    168. 
  
  
  
  
  168.              }  
    169. 
  
  
  
  
  169.    
    170. 
  
  
  
  
  170.              break;  
    171. 
  
  
  
  
  171.          }  
    172. 
  
  
  
  
  172.    
    173. 
  
  
  
  
  173.          ++version;  
    174. 
  
  
  
  
  174.      }  
    175. 
  
  
  
  
  175.    
    176. 
  
  
  
  
  176.      private bool ExpandBlock(int blockId)  
    177. 
  
  
  
  
  177.      {  
    178. 
  
  
  
  
  178.          var length = blocks[blockId].Length;  
    179. 
  
  
  
  
  179.          if (length == maxAllocSize)  
    180. 
  
  
  
  
  180.          {  
    181. 
  
  
  
  
  181.              return false;  
    182. 
  
  
  
  
  182.          }  
    183. 
  
  
  
  
  183.    
    184. 
  
  
  
  
  184.          length = Math.Min(length * 2, maxAllocSize);  
    185. 
  
  
  
  
  185.          Array.Resize(ref blocks[blockId], length);  
    186. 
  
  
  
  
  186.          return true;  
    187. 
  
  
  
  
  187.      }  
    188. 
  
  
  
  
  188.    
    189. 
  
  
  
  
  189.      private void UseNewBlock()  
    190. 
  
  
  
  
  190.      {  
    191. 
  
  
  
  
  191.          if (blockCount == blocks.Length)  
    192. 
  
  
  
  
  192.          {  
    193. 
  
  
  
  
  193.              Array.Resize(ref blocks, blockCount * 2);  
    194. 
  
  
  
  
  194.              Array.Resize(ref blockSizes, blockCount * 2);  
    195. 
  
  
  
  
  195.          }  
    196. 
  
  
  
  
  196.    
    197. 
  
  
  
  
  197.          blocks[blockCount] = new T[initAllocSize];  
    198. 
  
  
  
  
  198.          blockSizes[blockCount] = 0;  
    199. 
  
  
  
  
  199.          ++blockCount;  
    200. 
  
  
  
  
  200.      }  
    201. 
  
  
  
  
  201.  } 
    202.

分享名稱：.NET陷阱之奇怪的OutOfMemoryException
分享網(wǎng)址：http://www.5511xx.com/article/djghgsd.html