少有人走的路

勇哥注：

虽然C#有GC机制，但是内存泄露仍然是.net程序常见的问题。

有兴趣的童鞋和我一起学习下这方面的内容吧。

C# 内存泄露学习笔记（1）静态集合引发

示例 ：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace 静态集合引发泄露
{
    class Program
    {
        static void Main(string[] args)
        {
            WiFiManager wifi = new WiFiManager();
            //SomeOperation(wifi);

            //强制立即对所有代进行垃圾收集
            GC.Collect();
            //挂起当前线程，直到正在处理终结器已清空该队列。
            GC.WaitForPendingFinalizers();
            GC.Collect();

            var myclass = new MyClass(wifi);
            myclass = null;

            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }

        public static void SomeOperation(WiFiManager wiFiManager)
        {
            var myClass = new MyClass(wiFiManager);
            myClass.DoSomething();

            //... myClass在这里不会再被用到
        }

    }


    public class WifiEventArgs:EventArgs
    {
        public int p1 = 0;
        public WifiEventArgs(int p)
        {
            this.p1 = p;
        }
    }


    public class WiFiManager
    {
        public event EventHandler<WifiEventArgs> WiFiSignalChanged;
        // ...
    }
    public class MyClass
    {
        public static List<MyClass> list1 = new List<MyClass>();
        public MyClass(WiFiManager wiFiManager)
        {
            wiFiManager.WiFiSignalChanged += OnWiFiChanged;
        }



        private void OnWiFiChanged(object sender, WifiEventArgs e)
        {
            // do something
        }

        public void DoSomething()
        {
            Console.WriteLine("DoSomething。。。");
        }

        ~MyClass()
        {
            Console.WriteLine("2222");
        }
    }
}

程序运行后，注意终结器~MyClass()是没有被触发的。

这是因为静态集合list1的存在，造成这个类的全部实例都永远在内存中，不会被GC回收。

public static List<MyClass> list1 = new List<MyClass>();

下面的代码是作为没有内存分析工具时，判断对象是否存在内存泄露的一种技巧。

如果有泄露，则MyClass类不会触发终结器。

 GC.Collect();

 GC.WaitForPendingFinalizers();
 GC.Collect();

 var myclass = new MyClass(wifi);
 myclass = null;  //这里置null后，GC就会来收集这个对象

 GC.Collect();
 GC.WaitForPendingFinalizers();
 GC.Collect();

关于Dispose与Finalizer的对比：

我们知道：

Dispose主要用于释放非托管资源的。

Finalizer（终结器）为GC调用，用于释放托管资源。（千万不能在这里释放非托管资源 )

Dispose用两种用法：1. 显示调用  2. using语句隐式调用

Finalizer调用时机不可预测，由GC调用，你无法显式调用它。

finalizer的调用和GC的调用是运行在两个不同的线程里。如下：

   class ObjectWithFinalizer
    {
        ~ObjectWithFinalizer()
        {
            Thread.Sleep(1000);
            Console.WriteLine("Finalize in thread {0}", Thread.CurrentThread.ManagedThreadId);
        }
    }
    public static void Main()
    {
        Console.WriteLine("Run in thread {0}", Thread.CurrentThread.ManagedThreadId);
        ObjectWithFinalizer owf = new ObjectWithFinalizer();
        GC.Collect();
        Console.WriteLine("GC.Collect() end");
    }

    执行效果如下：

    Run in thread 1

    GC.Collect() end

    Finalize in thread 2

GC会将带有finalizer的垃圾对象标记，放入一个专门的队列，然后启动另一个线程来执行这个队列中的所有 finalizer。同时，GC继续回收其他垃圾对象占用的内存。等到下一次GC被调用时，GC会回收这个队列中执行过finalizer的垃圾对象。换句话说，带有finalizer的对象至少要经过两个GC调用才能被回收。

因此，finalizer对性能是有一定影响的。

本文出自勇哥的网站《少有人走的路》wwww.skcircle.com，转载请注明出处！讨论可扫码加群：