Memory accumulation/leak in .Net Queue class

[manojmohadikar2008]

Hi All,
We are observing a serious issue with the memory usage of Queue and its very critical issue which needs to be fixed.

We have an application which runs two threads i.e. a Producer and a Consumer thread. The Producer thread (Enqueue) inserts some heavy user defined object in the Queue. The Consumer thread (Dequeue) deletes one object from the Queue and processes it.

When we monitored the memory usage of this application in Task manager, we observed that there is a continuous rise in memory usage. After thousand insertions in the Queue, the Producer thread terminates and at this point the memory usage becomes constant. After deleting all the elements from the Queue, the Consumer thread also terminates.

However we observed that the memory usage for the application doesn't drop to the start value from where it has started even after removal of all elements from Queue. I implemented Dispose () for user defined classes and called GC.Collect (), GC.WaitForPendingFinalizers () and so that garbage collector should free all the memory taken up by the Queue. However after doing this, there is no drop observed in memory usage.

We also used ANT memory profiler tool in order to detect if there are live object references present in the queue, but the tool didn't showed any such live references.

One strange behavior we observed is, when the container object which has Queue object as a data member goes out of scope, Dispose () method does not get called for container object.But just before the termination of application, Dispose method gets called. Why the memory does not gets released or collected by GC when object goes out of Scope?

Is there any known memory accumulation problem with the Collection (i.e. for list, Queue and Arraylist) classes of .Net framework?

[debasisdas]

Hi Manoj

Welcome to Bytes.com (our new identity)

Feel free to post questions in the related forum only by choosing from under the blue bar on the top of your page.

Please follow the posting guidelines in every new post/reply.

Please specify your post/question clearly.

Regards
Debasis

[vekipeki]

If your class implements IDisposable, you should always call Dispose() manually.

A common misunderstanding is that GC will call your Dispose() method automatically -- actually no, it will only call Dispose() when you are enclosing your code in a C# using keyword.

One other thing that might be preventing GC from collecting your object is if you aren't detaching your event handlers (this does not count for event handlers added using Windows Forms designer, but counts for all other event handlers that you add inside your code).

So, for each

object.SomeEvent += new EventHandler(object_SomeEvent);

you should have a

object.SomeEvent -= new EventHandler(object_SomeEvent);

just before calling object's Dispose method.

I am used to putting all my handlers in two private methods for all my objects, AttachHandlers and DetachHandlers. The first one is usually called in a constructor, the other one just before disposing. Every event that is attached in a first method, must be detached in the second one.

For debugging, you can also add something like:

Console.WriteLine(this.ToString() + " disposed");

inside all your object's dectructors, just to check when your objects get disposed. Once you are sure that you are disposing properly, you should get rid of all forced GC.Collect() calls that you manually added and let the collector do it for you.