Component memory reclaimation

Question

Hello:
I have a general question about components specifically adding them to containers and removing them from the container.
When I create multiple instances of some custom component and add them to a container and eventually remove all components from the container, my memory is not reclaimed. I'm under the impression that once an object is no longer referenced it's eventually reclaimed; however, I can eventually cause an out of memory error with the code below. Could someone explain what I'm missing (or not understanding in Java)? My comments embedded in the program explain in more detail what I except as far as memory being restored.
import javax.swing.JComponent;
import javax.swing.JPanel;
public class test {
    public class foo extends JComponent {
        public foo() {
            setBounds(0, 0, 10, 10);
    public static void main(String[] args) {
        test t = new test();
        JPanel p = new JPanel(null); // absolute layout
        System.out.println("started");
        // create a bunch of components to see the memory go up
        for(int i = 0; i < 100000; i++)
            p.add(t.new foo());
        System.out.println("created multiple components");
        try {
            Thread.sleep(5000);
            // remove components and reclaim the memory
            // since there are no more hard references (so I think)
            p.removeAll();
            System.out.println("removed");
            // wait to see if the memory is reclaimed (and it isn't)
            Thread.sleep(20000);
        } catch (Exception e) { e.printStackTrace(); }
respectfully,
jjg

Answer 1

First of all, there's a difference between "can be reclaimed" and "will be reclaimed". Java specifies when an item can be reclaimed. But it explicitly states that it provides no guarantees whatsoever when a reclaim-able item will actually be reclaimed. When you say "I'm under the impression that once an object is no longer referenced it's eventually reclaimed" you're actually quite right. But the keyword is eventually. This "eventually" might very well be when the VM terminates.
You can try nudging the garbage collector through System.gc(). Still no hard guarantees though, but it's one step ahead.
Secondly, I'm not quite sure how you're measuring memory usage. Are you using something like windows' task manager? In that case, you shouldn't forget that the memory used by the java.exe process does not reflect the memory used by your program. Even if the VM freed it's internal memory, it might still stay allocated to the java.exe process.