Component not being garbage collected

[J. Ryan]

Hello,

I am working with an existing custom component that updates itself periodically. The component resides in its own JFrame which can be launched from my main application. The problem I'm having is that the component is not being garbage collected after its window has been closed. I've posted some simple sample code below. This is not the actual code, but it illustrates the issue.

The main class...

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class Main {

  public static void main(String[] args) {
    final JFrame primaryFrame = new JFrame("Primary Frame");
    final JButton button = new JButton("Create Custom Component");

    button.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {
        CustomLabel label = new CustomLabel();
        JFrame secondaryFrame = new JFrame("Secondary Frame");

        secondaryFrame.setContentPane(label);
        secondaryFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        secondaryFrame.pack();
        secondaryFrame.setLocationRelativeTo(primaryFrame);
        secondaryFrame.setVisible(true);
      }
    });

    primaryFrame.setContentPane(button);
    primaryFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    primaryFrame.pack();
    primaryFrame.setLocationRelativeTo(null);
    primaryFrame.setVisible(true);
  }
}

The custom component...

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JLabel;
import javax.swing.Timer;

public class CustomLabel extends JLabel {

  private int count = 0;

  public CustomLabel() {
    updateText();

    Timer timer = new Timer(1000, new ActionListener() {

      public void actionPerformed(ActionEvent e) {
        count++;
        updateText();
      }
    });
    timer.start();
  }

  private void updateText() {
    setText(String.valueOf(count));
    System.out.println(count);
  }
}

In the sample code, a Swing Timer is used to periodically update the label text. I also print out the value of count. But when the secondary frame is closed, the custom component continues to print out the value.

What am I doing wrong? How can I get the component to go out of scope and be garbage collected. What is the best practice for doing this type of thing? I would appreciate any insight. Thanks.

[Darryl Burke]

I just ran some tests and saw that a running Timer continues to run even when no longer in scope. Didn't go too deep in the sources, but it's probably still being referenced by the TimerQueue.

I suggest you add a ComponentListener to your custom component and stop() the Timer on componentHidden(...). OF course, after first makng the Timer an instance field instead of local to the constructor.

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import javax.swing.JLabel;
import javax.swing.Timer;

public class CustomLabel extends JLabel {

  private int count = 0;
  private Timer timer = new Timer(1000, new ActionListener() {

    @Override
    public void actionPerformed(ActionEvent e) {
      count++;
      updateText();
    }
  });

  public CustomLabel() {
    addComponentListener(new ComponentAdapter() {

      @Override
      public void componentShown(ComponentEvent e) {
        timer.start();
      }

      @Override
      public void componentHidden(ComponentEvent e) {
        timer.stop();
      }
    });
    updateText();
  }

  private void updateText() {
    setText(String.valueOf(count));
    System.out.println(count);
  }
}

Another approach could be to test the component's isDisplayable() in the Timer's actionPerformed.

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import javax.swing.JLabel;
import javax.swing.Timer;

public class CustomLabel extends JLabel {

  private int count = 0;
  private Timer timer;

  public CustomLabel() {
    updateText();

    timer = new Timer(1000, new ActionListener() {

      @Override
      public void actionPerformed(ActionEvent e) {
        count++;
        updateText();
        if (!CustomLabel.this.isDisplayable()) {
          timer.stop();
        }
      }
    });
    
    addComponentListener(new ComponentAdapter() {

      @Override
      public void componentShown(ComponentEvent e) {
        if (!timer.isRunning()) {
          timer.start();
        }
      }
    
    });
  }

  private void updateText() {
    setText(String.valueOf(count));
    System.out.println(count);
  }
}

[Darryl Burke]

After some more thinking about this, there's yet another approach that gives you finer control over when the Timer is stop()ped. That is to add a public void dispose() method to your CustomLabel that calls timer.stop() and invoke that method from your own code before the reference to the CustomLabel goes out of scope.

EDIT
Also with reference to your subject line, a Timer wouldn't stop when your references to it go out of scope. Think about it. When a Timer is created with a local variable referencing it, would you expect that Timer to stop firing events when the method in which it was declared returns? Of course not.

Timer#start() adds the timer to the TimerQueue and stop() removes it. So, as long as the timer is running the TimerQueue retains a reference to it and it can be GCed only after being stopped. Read the sources if you're interested in seeing where that's done.

Hope that makes things a little clearer.

[J. Ryan]

Thanks, Darryl.

After looking at the source for javax.swing.Timer, it makes sense to me now. I like the approach of adding a dispose() method. I can easily call it when the window is closed.