NewGlobalRef on a Queue object

Question

Hi,
I have a multi-threaded application. On the Java side I have a thread that creates a Queue object and then periodically pulls an item from the queue, processes the item, and removes the item from the queue.
Over in the C side, I use JNI to set up a Global Reference to the Queue and then over time, add items to the queue. When I am all done I call the DeleteGlobalReference on the queue object.
This works fine when I have a small amount of data to work on. However when I have a lot of data, JVM crashes with an out of memory error. I suspect that items aren't really being removed from the queue.
The question here then is If I use JNI to setup a Global Reference on a Queue or Container, do the items of the container actually get deleted during the lifetime of the container, or are they only deleted when I call the DeleteGlobalReference?
I posted a similar question in the Java Programming forum and then later saw this forum, so my apologies for posting a similar question in two places.
Thanks
David

Answer 1

Seems like your object isn't being garbage collected. Try to test your code on a small set of data and then test it on a large set of data and see the difference between memory usage. (You can get that by calling Runtime.totalMemory()-Runtime.freeMemory() ). You should also call Runtime.gc() periodically while you are testing.
Garbage collector works in this way: Everytime you have a reference to an object, i.e., declare a local variable to point to the object, add the object to a Container (Hashtable, Vector, etc), the reference count for that object increases by one. When the local variable goes out of scope or the object is removed from the container, the reference count is decreased by one. If the reference count for that object is 0, then that object can be safely garbage collected.
When you call NewGlobalRef on the object to be put on the Queue, you must also call RemoveGlobalRef after you are done (not with the object, but with the reference you have just created). So, make sure that if you execute NewGlobalRef on the object 3 times, you must also execute RemoveGlobalRef 3 times. Else it'll never be garbage collected.
There is another reason why it may not be garbage collected: circular reference. Typically, a circular reference do not happen in Java, and when it does, Java is smart enough to know and garbage collect correctly. However, in your JNI code, you may have unknowingly created a circular reference which Java garbage collector do not know about. i.e, you have ObjectA containing a reference to ObjectB, and ObjectB also contain a reference to ObjectA. Then the reference count for either object will never be 0.
Good luck