淺析c#內存泄漏

時間  2019-12-08
標籤 淺析 c# 內存 泄漏 欄目 C# 简体版
原文   原文鏈接

一直以來都對內存泄露和內存溢出理解的不是很深入。在網上看到了幾篇文章，因而整理了一下本身對內存泄露和內存溢出的理解。html

一.概念

內存溢出：指程序在運行的過程當中，程序對內存的需求超過了超過了計算機分配給程序的內存，從而形成「Out of memory」之類的錯誤，使程序不能正常運行。函數

形成內存溢出有幾種狀況： 1.計算機自己的內存小，當同時運行多個軟件時，計算機得內存不夠用從而形成內存溢出。對於這種狀況，只能增長計算機內存來解決。 2.軟件程序的問題，程序在運行時沒能及時釋放不用的內存，形成使用的內存愈來愈大從而形成內存溢出。對於這種狀況，能夠修改程序的代碼來解決。工具

內存泄露：內存泄漏指因爲疏忽或錯誤形成程序不能釋放或不能及時釋放已經再也不使用的內存的狀況，是應用程序分配某段內存後，因爲設計錯誤，失去了對該段內存的控制，於是形成了內存不能回收和不能及時回收。當程序不能釋放的內存愈來愈可能是就會形成程序的性能降低或出現內存溢出的錯誤。性能

2、內存泄露檢測工具：

1. SciTech Software AB .NET Memory Profiler－找到內存泄漏並優化內存使用針對C#，VB.Net，或其它.Net程序。單元測試

2. YourKit .NET & Java Profiler－業界領先的Java和.NET程序性能分析工具。測試

3. AutomatedQA AQTime－AutomatedQA的獲獎產品performance profiling和memory debugging工具集的下一代替換產品，支持Microsoft, Borland, Intel, Compaq 和 GNU編譯器。能夠爲.NET和Windows程序生成全面細緻的報告，從而幫助您輕鬆隔離並排除代碼中含有的性能問題和內存/資源泄露問題。支持.Net 1.0,1.1,2.0,3.0和Windows 32/64位應用程序。優化

4. JavaScript Memory Leak Detector－微軟全球產品開發歐洲團隊(Global Product Development- Europe team, GPDE) 發佈的一款調試工具，用來探測JavaScript代碼中的內存泄漏，運行爲IE系列的一個插件。this

5.使用LoadRunner，使用方法http://www.cnblogs.com/mayingbao/archive/2007/12/20/1006818.htmlspa

6.使用 .Net Memory Profiler 工具，使用方法見：http://lzy.iteye.com/blog/344317.net

7.在單元測試時，在代碼中檢測，如.net 下   使用Console.WriteLine("Total memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true));代碼能夠查看當前使用的內存。

 

2、致使內存泄露的常見狀況及解決方法：

1.未退訂的事件

是否沒有手動註銷事件就會形成內存泄露，咱們先看這個問題

[csharp]  view plain copy print ?
  1. class TestClassHasEvent     
  2.  {     
  3.      public delegate void TestEventHandler(object sender, EventArgs e);     
  4.      public event TestEventHandler YourEvent;     
  5.      protected void OnYourEvent(EventArgs e)     
  6.      {     
  7.          if (YourEvent != null) YourEvent(this, e);     
  8.      }     
  9.  }    
  10.       
  11.  class TestListener     
  12.  {    
  13.      byte[] m_ExtraMemory = new byte[1000000];    
  14.       
  15.      private TestClassHasEvent _inject;    
  16.       
  17.      public TestListener(TestClassHasEvent inject)    
  18.      {    
  19.          _inject = inject;    
  20.          _inject.YourEvent += new TestClassHasEvent.TestEventHandler(_inject_YourEvent);    
  21.      }    
  22.          
  23.      void _inject_YourEvent(object sender, EventArgs e)    
  24.      {    
  25.              
  26.      }    
  27.  }    
  28.       
  29.  class Program    
  30.  {    
  31.      static void DisplayMemory()    
  32.      {    
  33.          Console.WriteLine("Total memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true));    
  34.      }    
  35.       
  36.      static void Main()    
  37.      {    
  38.          DisplayMemory();    
  39.          Console.WriteLine();    
  40.          for (int i = 0; i < 5; i++)    
  41.          {    
  42.              Console.WriteLine("--- New Listener #{0} ---", i + 1);    
  43.       
  44.              var listener = new TestListener(new TestClassHasEvent());    
  45.             ////listener = null; //無關緊要    
  46.                  
  47.              GC.Collect();    
  48.              GC.WaitForPendingFinalizers();    
  49.              GC.Collect();    
  50.              DisplayMemory();    
  51.                  
  52.          }    
  53.          Console.Read();    
  54.      }    
  55.  }      
 class TestClassHasEvent   
  {   
      public delegate void TestEventHandler(object sender, EventArgs e);   
      public event TestEventHandler YourEvent;   
      protected void OnYourEvent(EventArgs e)   
      {   
          if (YourEvent != null) YourEvent(this, e);   
      }   
  }  
     
  class TestListener   
  {  
      byte[] m_ExtraMemory = new byte[1000000];  
     
      private TestClassHasEvent _inject;  
     
      public TestListener(TestClassHasEvent inject)  
      {  
          _inject = inject;  
          _inject.YourEvent += new TestClassHasEvent.TestEventHandler(_inject_YourEvent);  
      }  
        
      void _inject_YourEvent(object sender, EventArgs e)  
      {  
            
      }  
  }  
     
  class Program  
  {  
      static void DisplayMemory()  
      {  
          Console.WriteLine("Total memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true));  
      }  
     
      static void Main()  
      {  
          DisplayMemory();  
          Console.WriteLine();  
          for (int i = 0; i < 5; i++)  
          {  
              Console.WriteLine("--- New Listener #{0} ---", i + 1);  
     
              var listener = new TestListener(new TestClassHasEvent());  
             ////listener = null; //無關緊要  
                
              GC.Collect();  
              GC.WaitForPendingFinalizers();  
              GC.Collect();  
              DisplayMemory();  
                
          }  
          Console.Read();  
      }  
  }

運行結果： 

咱們來改一行代碼:

把下面這段：

[csharp]  view plain copy print ?
  1. public TestListener(TestClassHasEvent inject)     
  2. {     
  3.     _inject = inject;     
  4.     _inject.YourEvent += new TestClassHasEvent.TestEventHandler(_inject_YourEvent);     
  5. }  
 public TestListener(TestClassHasEvent inject)   
 {   
     _inject = inject;   
     _inject.YourEvent += new TestClassHasEvent.TestEventHandler(_inject_YourEvent);   
 }

改爲：

[csharp]  view plain copy print ?
  1. public TestListener(TestClassHasEvent inject)     
  2. {     
  3.     SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);     
  4. }     
  5.       
  6. void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)     
  7. {     
  8.        
  9. }  
 public TestListener(TestClassHasEvent inject)   
 {   
     SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);   
 }   
     
 void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)   
 {   
      
 }

看看運行結果：

 內存泄露了

加個Dispose手動註銷事件，而後使用Using關鍵字，就沒有問題了

[csharp]  view plain copy print ?
  1. class TestListener : IDisposable     
  2. {     
  3.     byte[] m_ExtraMemory = new byte[1000000];    
  4.       
  5.     private TestClassHasEvent _inject;     
  6.       
  7.     public TestListener(TestClassHasEvent inject)    
  8.     {    
  9.         SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);    
  10.     }    
  11.      
  12.     void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)    
  13.     {    
  14.           
  15.     }    
  16.        
  17.     #region IDisposable Members    
  18.      
  19.     public void Dispose()    
  20.      {    
  21.         SystemEvents.DisplaySettingsChanged -= new EventHandler(SystemEvents_DisplaySettingsChanged);    
  22.     }    
  23.      
  24.     #endregion    
  25. }    
  26.      
  27. class Program    
  28. {    
  29.     static void DisplayMemory()    
  30.     {    
  31.          Console.WriteLine("Total memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true));    
  32.     }    
  33.      
  34.     static void Main()    
  35.     {    
  36.         DisplayMemory();    
  37.         Console.WriteLine();    
  38.         for (int i = 0; i < 5; i++)    
  39.         {    
  40.              Console.WriteLine("--- New Listener #{0} ---", i + 1);    
  41.                 
  42.             using (var listener = new TestListener(new TestClassHasEvent()))    
  43.             {    
  44.                  //do something    
  45.              }    
  46.             GC.Collect();    
  47.              GC.WaitForPendingFinalizers();    
  48.             GC.Collect();    
  49.             DisplayMemory();    
  50.                 
  51.         }    
  52.         Console.Read();    
  53.     }    
  54. }  
 class TestListener : IDisposable   
 {   
     byte[] m_ExtraMemory = new byte[1000000];  
     
     private TestClassHasEvent _inject;   
     
     public TestListener(TestClassHasEvent inject)  
     {  
         SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);  
     }  
    
     void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)  
     {  
         
     }  
       
     #region IDisposable Members  
    
     public void Dispose()  
      {  
         SystemEvents.DisplaySettingsChanged -= new EventHandler(SystemEvents_DisplaySettingsChanged);  
     }  
     
     #endregion  
 }  
    
 class Program  
 {  
     static void DisplayMemory()  
     {  
          Console.WriteLine("Total memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true));  
     }  
    
     static void Main()  
     {  
         DisplayMemory();  
         Console.WriteLine();  
         for (int i = 0; i < 5; i++)  
         {  
              Console.WriteLine("--- New Listener #{0} ---", i + 1);  
               
             using (var listener = new TestListener(new TestClassHasEvent()))  
             {  
                  //do something  
              }  
             GC.Collect();  
              GC.WaitForPendingFinalizers();  
             GC.Collect();  
             DisplayMemory();  
               
         }  
         Console.Read();  
     }  
 }

上面兩個例子一個內存泄露，一個沒有內存泄露，我想你應該知道緣由了，根本區別在於後者有個SystemEvents.DisplaySettingsChanged事件，這個事件是靜態Static事件，因此綁定到這個事件上的對象都不會被釋放

[csharp]  view plain copy print ?
  1. // Type: Microsoft.Win32.SystemEvents  
  2. // Assembly: System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089  
  3. // Assembly location: C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\Profile\Client\System.dll  
  4.    
  5.  using System;  
  6.  using System.ComponentModel;  
  7.     
  8.  namespace Microsoft.Win32  
  9.  {  
  10.      public sealed class SystemEvents  
  11.      {  
  12.          public static IntPtr CreateTimer(int interval);  
  13.          public static void InvokeOnEventsThread(Delegate method);  
  14.          public static void KillTimer(IntPtr timerId);  
  15.          public static event EventHandler DisplaySettingsChanging;  
  16.          public static event EventHandler DisplaySettingsChanged;  
  17.          public static event EventHandler EventsThreadShutdown;  
  18.          public static event EventHandler InstalledFontsChanged;  
  19.      
  20.          [EditorBrowsable(EditorBrowsableState.Never)]  
  21.          [Obsolete("This event has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]  
  22.          [Browsable(false)]  
  23.          public static event EventHandler LowMemory;  
  24.     
  25.          public static event EventHandler PaletteChanged;  
  26.          public static event PowerModeChangedEventHandler PowerModeChanged;  
  27.          public static event SessionEndedEventHandler SessionEnded;  
  28.          public static event SessionEndingEventHandler SessionEnding;  
  29.          public static event SessionSwitchEventHandler SessionSwitch;  
  30.          public static event EventHandler TimeChanged;  
  31.          public static event TimerElapsedEventHandler TimerElapsed;  
  32.          public static event UserPreferenceChangedEventHandler UserPreferenceChanged;  
  33.          public static event UserPreferenceChangingEventHandler UserPreferenceChanging;  
  34.        }  
  35. }  
// Type: Microsoft.Win32.SystemEvents
// Assembly: System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// Assembly location: C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\Profile\Client\System.dll
 
 using System;
 using System.ComponentModel;
  
 namespace Microsoft.Win32
 {
     public sealed class SystemEvents
     {
         public static IntPtr CreateTimer(int interval);
         public static void InvokeOnEventsThread(Delegate method);
         public static void KillTimer(IntPtr timerId);
         public static event EventHandler DisplaySettingsChanging;
         public static event EventHandler DisplaySettingsChanged;
         public static event EventHandler EventsThreadShutdown;
         public static event EventHandler InstalledFontsChanged;
   
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This event has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
         [Browsable(false)]
         public static event EventHandler LowMemory;
  
         public static event EventHandler PaletteChanged;
         public static event PowerModeChangedEventHandler PowerModeChanged;
         public static event SessionEndedEventHandler SessionEnded;
         public static event SessionEndingEventHandler SessionEnding;
         public static event SessionSwitchEventHandler SessionSwitch;
         public static event EventHandler TimeChanged;
         public static event TimerElapsedEventHandler TimerElapsed;
         public static event UserPreferenceChangedEventHandler UserPreferenceChanged;
         public static event UserPreferenceChangingEventHandler UserPreferenceChanging;
       }
}

注意Static，注意Singleton 這種static的東西生命週期很長，永遠不會被GC回收，一旦被他給引用上了，那就不可能釋放了。上面的例子就是SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);那就意味着這個類被SystemEvents.DisplaySettingsChanged 引用了，經過它的函數。另一個要注意的是Singleton單例模式實現的類，他們也是static的生命週期很長，要注意引用鏈，你的類是否被它引用上，若是在它的引用鏈上，就內存泄露了。

另外還有注意程序運行期間不會釋放的對象的事件

還有一種狀況，既不是你的對象被static對象而不能釋放，也不是Singleton，而是你的對象被一個永遠不釋放的對象引用着，這個對象或許不是static的。這種類型不少，好比你的界面有個MainForm，嘿嘿，這個MainForm永遠不會關閉和釋放的，被它引用了那就不會釋放了。看個例子：

MainForm裏面有個public event，MainForm裏面打開Form2，而後關閉，看看Form2能不能釋放：

[csharp]  view plain copy print ?
  1. public partial class MainForm : Form     
  2. {     
  3.     public event PropertyChangedEventHandler PropertyChanged;     
  4.       
  5.    protected virtual void OnPropertyChanged(string propertyName)     
  6.    {     
  7.         PropertyChangedEventHandler handler = PropertyChanged;     
  8.       
  9.         if (handler != null)    
  10.             handler(this, new PropertyChangedEventArgs(propertyName));    
  11.     }    
  12.      
  13.     public MainForm()    
  14.     {    
  15.         InitializeComponent();    
  16.     }    
  17.      
  18.     private void button1_Click(object sender, EventArgs e)    
  19.     {    
  20.         Form2 frm = new Form2();   
  21.      
  22.         this.PropertyChanged += frm.frm_PropertyChanged;     
  23.         //MainForm referenced form2, because main form is not released, therefore form2 will not released.    
  24.      
  25.         DialogResult d = frm.ShowDialog();    
  26.             
  27.         GC.Collect();    
  28.         ShowTotalMemory();    
  29.      
  30.     }    
  31.      
  32.         
  33.     
  34.     private void ShowTotalMemory()    
  35.     {    
  36.         this.listBox1.Items.Add(string.Format("Memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true)));    
  37.     }    
  38. }  
 public partial class MainForm : Form   
 {   
     public event PropertyChangedEventHandler PropertyChanged;   
     
    protected virtual void OnPropertyChanged(string propertyName)   
    {   
         PropertyChangedEventHandler handler = PropertyChanged;   
     
         if (handler != null)  
             handler(this, new PropertyChangedEventArgs(propertyName));  
     }  
    
     public MainForm()  
     {  
         InitializeComponent();  
     }  
    
     private void button1_Click(object sender, EventArgs e)  
     {  
         Form2 frm = new Form2(); 
    
         this.PropertyChanged += frm.frm_PropertyChanged;   
         //MainForm referenced form2, because main form is not released, therefore form2 will not released.  
    
         DialogResult d = frm.ShowDialog();  
           
         GC.Collect();  
         ShowTotalMemory();  
    
     }  
    
       
   
     private void ShowTotalMemory()  
     {  
         this.listBox1.Items.Add(string.Format("Memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true)));  
     }  
 }

Form2裏面有個函數：

[csharp]  view plain copy print ?
  1. public partial class Form2 : Form     
  2.  {     
  3.      public Form2()     
  4.      {     
  5.          InitializeComponent();     
  6.      }     
  7.      public void frm_PropertyChanged(object sender, PropertyChangedEventArgs e)     
  8.      {     
  9.       
  10.      }    
  11.  }  
public partial class Form2 : Form   
 {   
     public Form2()   
     {   
         InitializeComponent();   
     }   
     public void frm_PropertyChanged(object sender, PropertyChangedEventArgs e)   
     {   
    
     }  
 }

因此這種狀況下，你的Event handler沒有手動註銷，那就確定內存泄露了。

 

2.靜態變量

靜態變量中的成員所佔的內存不果不手動處理是不會釋放內存的，單態模式的對象也是靜態的，因此須要特別注意。由於靜態對象中的成員所佔的內存不會釋放，若是此成員是以個對象，同時此對象中的成員所佔的內存也不會釋放，以此類推，若是此對象很複雜，並且是靜態的就很容易形成內存泄露。

3.非託管資源

由於非託管資源所佔的內存不能自動回收，因此使用後必須手動回收，不然程序運行屢次很容易形成內存泄露

4.Dispose方法沒被調用，或Dispose方法沒有處理對象的釋放。這樣也會形成內存泄露

5.當一個查詢語句查詢出來的數據量很大，達到幾百萬條數據時存放到datatable 或dataset中也會形成內存溢出，這是能夠採用分頁查詢等其餘方法來解決

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程