Stopping a Swing timer when a component is hidden

Question

I have a Swing timer (javax.swing.Timer) which is used to perform some animation within a custom Swing component.

However, this is causing problems - in particular it seems to stop the application from terminating because of the live timer thread even after all windows are closed. Also it would be nice to avoid the overhead of timers running on hidden objects when the animation cannot be seen.

Ideally I'd like to do the following:

Stop the timer when the component is hidden
Start the time again whenever the component becomes visible

Is this possible to do (in a thread-safe way of course!)

hmm .. what's wrong with an ancestorListener (which would be my first thought)? — kleopatra, Sep 16 '12 at 11:20
Or you can add one [ComponentListener](http://docs.oracle.com/javase/7/docs/api/java/awt/event/ComponentListener.html) to it and add **timer.start()/stop() inside it's componentHidden(...) and componentShown(...) methods** — nIcE cOw, Sep 16 '12 at 12:36
@GagandeepBalin a componentListener only is a kind-of propertyChangeListener to the visible property of a single component, which isn't changed if f.i. an ancestor is hidden/shown. — kleopatra, Sep 16 '12 at 12:53

score 5 · Accepted Answer · edited May 23 '17 at 12:34

I am skeptical of your first premise: this simple counter-example shows that a running javax.swing.Timer does not preclude EXIT_ON_CLOSE. The package-private, shared javax.swing.TimerQueue starts a daemon thread, which allows Program Exit. You may be understandably reluctant to rely on this implementation detail, but it may be worth looking for another reason your program fails to exit.

If defer to @kleopatra on AncestorListener; it should allow you to control the Timer as desired. The duty cycle of a component animation is typical fairly light, and it's usually dominated by rendering; the latter's overhead is small when the component is not visible. It may be worth profiling to verify that the proposed optimization is worth the effort. If so, consider a WindowListener to minimize activity in an inactive or iconified window.

Addendum: A now deleted answer suggested overriding setVisible() to condition the timer. While superficially appealing, the approach is brittle and scales poorly. The listener approach leverages the observer pattern commonly used in Swing architecture.

Thanks, this approach worked well (actually I used a HeirarchyListener in order to be able to catch some other events but I think the principle is the same). I also think you are also right on the timers, but as you say it may be best not rely on that behaviour! — mikera, Sep 17 '12 at 00:11
For reference, here's a related [example](http://stackoverflow.com/q/10880326/230513) that compares the three listeners mentioned. — trashgod, Sep 17 '12 at 00:26

score 1 · Answer 2 · answered Jul 02 '13 at 06:40

The event queue should be quiet for one second for the shutdown to be initialized. That is a hard-coded value in AWTAutoShutdown class.

So if your swing timer keeps generating events, less then a second apart, that would keep the application from terminate.

Look at this example (below). It would not terminate, because the thread, even though it marked as deamon, keeps adding events to the queue. If we increase the sleep to 1500 (1.5 seconds) - it would terminate happily.

public static void main(String[] args)
{
    Thread thread = new Thread(new Runnable()
    {
        @Override
        public void run()
        {
            while (true)
            {
                // Submit an empty event to the queue
                EventQueue.invokeLater(new Runnable()
                {
                    @Override
                    public void run()
                    {
                    }
                });
                try
                {
                    Thread.sleep(500);
                }
                catch (InterruptedException e)
                {
                    throw new IllegalStateException(e);
                }
            }
        }
    });
    thread.setDaemon(true);
    thread.start();
}

score 1 · Answer 3 · answered Jul 02 '13 at 08:22

We do it like this:

  private static final class DisplayabilityListener implements HierarchyListener {
  private final JComponent component;
  private final Timer timer;

  private DisplayabilityListener(JComponent component, Timer timer) {
     this.component = component;
     this.timer = timer;
  }

  @Override
  public void hierarchyChanged(HierarchyEvent e) {
     if ((e.getChangeFlags() & HierarchyEvent.DISPLAYABILITY_CHANGED) > 0) {
        if (component.isDisplayable()) {
           timer.start();
        } else {
           timer.stop();
        }
     }
  }

}

I would change the `if ((x & y) > 0)` into `if ((x & y) != 0)`, as it won't work if `y` has its MSB set. — Matthieu, Apr 22 '16 at 14:07

Stopping a Swing timer when a component is hidden

3 Answers3