C＃线程已经完成时如何导致内存泄漏？

Question

Here's my code:

using System;
using System.Collections.Generic;
using System.Threading;
namespace testt
{
    class MainClass
    {
        public static List<TestObject> testjobs = new List<TestObject> ();
        public static void Main (string[] args)
        {
            Console.WriteLine ("Hello World!");
            addTask (); //put a breakpoint here
            Thread.Sleep (5000);
            deleteObj ();
            while (true) {
                Console.WriteLine ("MAIN STILL EXISTS!");
                Thread.Sleep (1500);
                GC.Collect ();
            }
        }
        public static void addTask()
        {
            for (int i = 0; i < 10; i++)
            {
                testjobs.Add (new TestObject ());
                testjobs [i].Start ();
            }
        }

        public static void deleteObj()
        {
            for(int i=0; i<10;i++)
            {
                testjobs [0].dispose ();
                testjobs.RemoveAt (0);
            }
            Console.WriteLine (testjobs.Count);
        }

    }

    public class TestObject
    {

        private bool _isStopRequested;
        private Thread _thread;
        public void Start()
        {
            _thread = new Thread(ThreadRoutine);
            _thread.Start();
        }

        public void Stop()
        {
            _isStopRequested = true;
            if(!_thread.Join(5000))
            {
                _thread.Abort();
            }
        }

        public void dispose(){
            this.Stop ();
            this._thread.Abort ();
            this._thread=null;
        }


        private void ThreadRoutine()
        {
            //while(!_isStopRequested) //THIS CAUSES THE MEMORY LEAK!!!
            {
            Thread.Sleep (1);
            }
            Console.WriteLine ("THREAD FINISHED");
        }

        ~TestObject(){
            Console.WriteLine ("===================TESTOBJECT DESTROYED!!===============");
        }
    }
}

If you run it with the //while(!_isStopRequested) uncommented, the TestObject instances will not be destroyed, ie their destructor methods will not be called.

If you run it as is, then only 4-8 objects will be destroyed, not all 10 of them.

Why does this happen when the threads have fully exited? I checked with the Xamarin debugger and the threads were definitely stopped. If you put a breakpoint in Xamarin at addTask(); then you can see that 10 threads

My only explanation for this is that the thread somehow holds a reference back to their parent object TestObject instance even after they have finished. How can a thread hold a reference to their parent object when the thread has already finished?

Also, if I change Thread.Sleep(1) to Thread.Sleep(5000) , the TestObjects also stop being collected.

Also, as it is, only some TestObjects get collected whilst others don't.

Why do these things happen? How can I ensure that ALL the TestObjects get garbage collected by the time the deleteObj() function returns?

EDIT: I just tested the exact same code in Visual Studio (.NET) and all of the objects were garbage collected regardless of whether if that line was commented out or not.

Therefore I now consider this issue to be a Mono-specific problem and there was no memory leak to begin with.

Answer 1

Finalizers are not deterministic. You cannot rely on them being called.

If it is vitally important for your program to clean up the resource in question then you should be explicitly disposing of it, and not relying on a finalizer.

If cleaning up the resource would be nice, but you don't really care all that much if the finializer gets to it or not, then you can choose to not explicitly dispose of the unmanaged resources.

Also note that making a managed object eligible for garbage collection doesn't necessarily mean that it will be garbage collected. It means it can be collected whenever the collector feels like it.

Finally, recognize that aborting a thread is another unreliable thing to do. The thread do. There are a number of ways for a thread that has been requested to abort will not successfully do so, or where it will cause any number of different types of problems when it does. You should avoid using Thread.Abort unless the thread in question was designed to be aborted, and you have a strong understanding of all of the many possible pitfalls of trying to reason about a program that could throw an exception between any two operations.