翼度科技»论坛 编程开发 .net 查看内容

避坑:.NET内存泄露的几种情况

3

主题

3

帖子

9

积分

新手上路

Rank: 1

积分
9
内存“泄露”是开发中常见的问题之一,它会导致应用程序占用越来越多的内存资源,最终可能导致系统性能下降甚至崩溃。软件开发者需要了解在程序中出现内存泄露的情况,以避免软件出现该的问题。
什么是内存“泄露”?
内存泄露是申请了内存空间的变量一直在占用,无法释放。比如申请了一块内存空间,没有回收一直占用,直到最后内存溢出。
在.NET应用程序中,可能会出现以下几种情况导致内存泄漏。
1、 对象保持的引用过长

  • 情况:某个对象持有对其他对象的引用,并且该引用没有被正确释放。
  • 示例:一个长时间运行的任务中,持有对大量对象的引用,但任务执行完毕后未释放这些对象的引用。
  • 解决方案:在不再需要对象时,及时释放对其的引用。确保在任务完成后,所有不再需要的对象都被正确释放。
  1. public class LongRunningTask
  2. {
  3.     private List<object> objects; // 对象列表
  4.     public LongRunningTask()
  5.     {
  6.         objects = new List<object>();
  7.     }
  8.     public void RunTask()
  9.     {
  10.         // 执行长时间运行的任务
  11.         // 将对象添加到列表中
  12.         objects.Add(new object());
  13.         objects.Add(new object());
  14.         // ...
  15.     }
  16.     //用完后用这个方法释放对象列表
  17.     public void Cleanup()
  18.     {
  19.         // 在任务完成后清理对象列表
  20.         objects.Clear();
  21.         objects = null; // 释放对列表对象的引用
  22.     }
  23. }
复制代码
在上述示例中,LongRunningTask 类代表一个长时间运行的任务,它持有对一些对象的引用。在任务完成后,通过调用 Cleanup() 方法释放对对象列表的引用,从而允许垃圾回收器回收这些对象。
2、 事件处理未正确解注册

  • 情况:在应用程序中订阅了事件,但没有在不再需要时正确解注册。
  • 示例:一个对象订阅了另一个对象的事件,但在对象不再需要时忘记解注册事件。
  • 解决方案:在不再需要订阅事件时,确保正确解注册事件。可以在对象的生命周期结束时,手动调用事件的解注册方法或使用弱事件模式,以避免事件发布者持有订阅者的引用。
  1. public class EventPublisher
  2. {
  3.     public event EventHandler SomeEvent;
  4.     public void PublishEvent()
  5.     {
  6.         // 发布事件
  7.         SomeEvent?.Invoke(this, EventArgs.Empty);
  8.     }
  9.     public void UnsubscribeEvent(EventHandler handler)
  10.     {
  11.         // 解注册事件处理程序
  12.         SomeEvent -= handler;
  13.     }
  14. }
  15. public class EventSubscriber
  16. {
  17.     private EventPublisher publisher;
  18.     public EventSubscriber(EventPublisher publisher)
  19.     {
  20.         this.publisher = publisher;
  21.         // 订阅事件
  22.         publisher.SomeEvent += HandleEvent;
  23.     }
  24.     private void HandleEvent(object sender, EventArgs e)
  25.     {
  26.         // 处理事件
  27.     }
  28.     public void UnsubscribeFromEvent()
  29.     {
  30.         // 解注册事件处理程序
  31.         publisher.UnsubscribeEvent(HandleEvent);
  32.     }
  33. }
复制代码
在上述示例中,EventPublisher 类发布了一个事件 SomeEvent,EventSubscriber 类订阅了该事件。通过调用 UnsubscribeFromEvent() 方法,解注册事件处理程序,从而释放对事件发布者的引用。
3、长时间运行的后台任务:

  • 情况:应用程序中存在长时间运行的后台任务,这些任务持有对其他对象的引用,并且这些引用没有被正确释放。
  • 示例:一个后台线程持续运行并持有对大量对象的引用,但这些对象在任务完成后不再需要。
  • 解决方案:在后台任务完成后,及时释放对其他对象的引用。可以通过在任务执行完毕后手动解除引用,或使用异步编程模型,确保任务完成后自动释放引用。
  1. public class BackgroundTask
  2. {
  3.     private CancellationTokenSource cancellationTokenSource;
  4.     public void StartTask()
  5.     {
  6.         cancellationTokenSource = new CancellationTokenSource();
  7.         Task.Run(() =>
  8.         {
  9.             // 长时间运行的后台任务
  10.             while (!cancellationTokenSource.Token.IsCancellationRequested)
  11.             {
  12.                 // 执行任务逻辑
  13.             }
  14.         }, cancellationTokenSource.Token);
  15.     }
  16.     public void StopTask()
  17.     {
  18.         cancellationTokenSource?.Cancel();
  19.         cancellationTokenSource?.Dispose();
  20.         cancellationTokenSource = null; // 释放对 CancellationTokenSource 对象的引用
  21.     }
  22. }
复制代码
在上述示例中,BackgroundTask 类代表一个长时间运行的后台任务。通过调用 StartTask() 方法启动任务,并在适当的时候调用 StopTask() 方法停止任务。在停止任务时,通过取消 CancellationTokenSource 对象来结束任务,并释放对该对象的引用。
4、大对象没有被正确释放

  • 情况:大对象(如大型数组、大型集合等)占用大量内存,但在不再需要时没有被正确释放。
  • 示例:一个应用程序在运行过程中创建了大量大型对象,但这些对象在使用后未被正确释放。
  • 解决方案:在使用完大对象后,及时释放不再需要的部分或整个对象。可以使用`Dispose`方法或使用`using`语句来确保资源的正确释放。
  1. public void ProcessLargeData()
  2. {
  3.     byte[] largeData = new byte[100000000]; // 创建一个大型数组
  4.     // 处理大型数据
  5.     // ...
  6.     // 使用完大型数组后,及时释放
  7.     largeData = null;
  8. }
复制代码
在上述示例中,创建了一个大型数组 largeData 来存储大量数据。在处理完数据后,通过将 largeData 设置为 null,释放对大型数组的引用,从而允许垃圾回收器回收该数组所占用的内存。
5、 不正确使用IDisposable接口

  • 情况:在使用实现了IDisposable接口的对象时,没有正确调用`Dispose`方法来释放资源。
  • 示例:一个对象实现了IDisposable接口,但在使用完对象后忘记调用`Dispose`方法。
  • 解决方案:在使用完实现了IDisposable接口的对象后,使用`using`语句或手动调用`Dispose`方法来释放资源。确保正确地管理实现了IDisposable接口的对象。
  1. public class CustomResource : IDisposable
  2. {
  3.     private bool disposed = false;
  4.     public void Dispose()
  5.     {
  6.         Dispose(true);
  7.         GC.SuppressFinalize(this);
  8.     }
  9.     protected virtual void Dispose(bool disposing)
  10.     {
  11.         if (!disposed)
  12.         {
  13.             if (disposing)
  14.             {
  15.                 // 释放托管资源
  16.             }
  17.             // 释放非托管资源
  18.             // ...
  19.             disposed = true;
  20.         }
  21.     }
  22.     ~CustomResource()
  23.     {
  24.         Dispose(false);
  25.     }
  26. }
  27. //欢迎关注公众号:DOTNET开发跳槽,领取海量面试题。加微信号xbhpnet入群交流
复制代码
在上述示例中,CustomResource 类实现了 IDisposable 接口。在 Dispose() 方法中,通过调用 Dispose(true) 来释放托管资源,通过调用 Dispose(false) 来释放非托管资源。在 CustomResource 类的析构函数中,调用 Dispose(false) 来确保资源的释放。使用时,应该在不再需要 CustomResource 对象时调用 Dispose() 方法,或使用 using 语句来自动释放资源。
结语
请注意,以上示例仅用于说明可能的内存泄漏情况和解决方案,并不一定适用于所有具体的应用程序。在实际开发中,应根据应用程序的特性和需求,仔细审查代码并确保正确的资源管理和释放,以避免内存泄漏问题的出现。
以上只列举了几种情况,还有其它情况,比如在代码中使用了静态变量也容易导致内存泄露。希望本文对你有所收获,欢迎留言和吐槽。
版权声明:本文来源于网友收集或网友供稿,仅供学习交流之用,如果有侵权,请转告小编或者留言,本公众号立即删除。
  1. 来源公众号:DotNet开发跳槽
复制代码
来源:https://www.cnblogs.com/xbhp/archive/2023/07/03/17522450.html
免责声明:由于采集信息均来自互联网,如果侵犯了您的权益,请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容,谢谢合作!

举报 回复 使用道具