automatically causing a subclassed JPanel's resources to be released

Question

Suppose I subclass JPanel, and my subclass uses a lot of memory.

What is the right way for me to design this class so that the memory resources are freed when my JPanel is used as a component in a larger system?

Seems like there's a few options:

subclass finalize() (red flags all over the place -- the literature I've read says you shouldn't get into the finalizing business)
add an explicit dispose() or destroy() or whatever, for consumers of my class to use
add some kind of listener to my JPanel that gets notified when the parent gets disposed
override some method of JPanel which will automatically get called when their parent window gets disposed

In the example below I used the finalize() option, which works but only when garbage collection gets called, and there are instances where I'd rather the cleanup happens when the JPanel is no longer needed.

Option #2 is nice, but then I have to rely on consumers to call this method, and the Swing philosophy seems to be just stick components into a window, and let all the components get destroyed when the window gets closed. So if my JPanel is inside a JTable in a JScrollPane in a JPanel in a JFrame, chances are, the consumer of my class isn't going to call my dispose() or destroy() method.

Options #3 or #4 would be my choice but I can't find anything that seems to apply here.

Any suggestions?

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class JPanelMemoryHog extends JPanel
{
    final private String title;
    final private Object space;

    public JPanelMemoryHog(String title)
    {
        super();
        this.title = title;
        this.space = new byte[5*1000*1000];
        setBorder(BorderFactory.createTitledBorder(title));
        setPreferredSize(new Dimension(300,200));
    }

    @Override protected void finalize()
    {
        System.out.println("finalized "+this.title);
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("example");
        JPanel panel = new JPanel();
        panel.setLayout(new BorderLayout());
        JButton button = new JButton("create frame");
        button.addActionListener(new ActionListener() {
            @Override public void actionPerformed(ActionEvent e) {
                createFrame();
            }
        });
        panel.add(button, BorderLayout.CENTER);
        frame.setContentPane(panel);
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }

    private static int panelcount = 0;
    protected static void createFrame() {
        final String title = "panel"+(++panelcount);
        final JFrame frame = new JFrame(title);
        frame.setContentPane(new JPanelMemoryHog(title));
        frame.pack();
        frame.addWindowListener(new WindowAdapter() {
            @Override public void windowClosing(WindowEvent e) {
                System.out.println("closing "+title);
                frame.dispose();
            }
        });
        frame.setVisible(true);
    }   
}

Could you add the panel to a JDialog?. Once the dialog is closed it should ensure your panel is garbage collected by default, without any specific listeners/events/finialise()/destroy() messing. — emeraldjava, May 31 '11 at 15:50
@emeraldjava that's not true at all about JDialog, the first one is never GC'ed, but light to the tunnel give us this Woodoo by trashgod for JDialog http://stackoverflow.com/questions/5540354/java-swing-the-right-action-to-take-upon-closing-windows/5540802#5540802 — mKorbel, May 31 '11 at 15:59

score 5 · Answer 1 · edited Jan 30 '13 at 16:06

5

The best solution is to add a HierarchyListener to the JPanel and then check for HierarchyEvent.DISPLAYABILITY_CHANGED (which get triggered when the parent dialog is shown and disposed) and then check for isDisplayable() to false which is the condition set when it is in the process of disposing.

public void hierarchyChanged(HierarchyEvent e) {
   //check for Hierarchy event
   if(e.getChangeFlags() == HierarchyEvent.DISPLAYABILITY_CHANGED)
   {       
        //do the required action upon close
       if(!this.isDisplayable())                         
          Notifier.removeListener(this);

   }
}

edited Jan 30 '13 at 16:06

akjoshi

15,374
13
103
121

answered Jan 30 '13 at 15:45

user2026007

51
1
2

1

Interesting... could you link the isDisplayable() to the Javadoc e.g. http://docs.oracle.com/javase/7/docs/api/java/awt/Component.html#isDisplayable() which states "A component is made undisplayable either when it is removed from a displayable containment hierarchy or when its containment hierarchy is made undisplayable. A containment hierarchy is made undisplayable when its ancestor window is disposed." My concern would be if it is removed from a displayable containment hierarchy but later placed into a different one, in which case I should *not* dispose resources. – Jason S Jan 30 '13 at 18:09
1

Instead of comparing `e.getChangeFlags()` to `DISPLAYABILITY_CHANGED` it is better to use bitwise AND. – lambdas May 17 '17 at 09:51

score 0 · Answer 2 · answered May 31 '11 at 17:41

Like you mentioned, don't call finalize(), this is just dangerous and hard to get right.

I've always added dispose methods that take care of listener cleanup and removing any memory intensive resources. I think the trick to doing this properly, is there should be a manager of some sort that handles destroying such objects.

If you're talking about more generic components that would be used in a more general framework this might not be the correct solution

automatically causing a subclassed JPanel's resources to be released

2 Answers2