How to pause execution for X milliseconds in AWTEventQueue

Question

I have a game where I want to flash a component a red color, and then back to its normal color after a short delay. Obviously, I could just do Thread.sleep(123), but that is EXTREMELY undesirable because it breaks stuff on my UI. Plus, I am pretty sure that is not what I am supposed to do here.

Now, I could just do the pause off the queue, and then use SwingUtilities::invokeLater. But I wanted to ask to learn the best practices here.

What is the best way to add a specific length pause in between Swing/AWT Events?

Here is a runnable example.

import javax.swing.*;
import java.awt.*;

public class cry {

    public static void main(final String[] args) {

        SwingUtilities.invokeLater(cry::blah);

    }

    private static void blah() {
        final JFrame frame = new JFrame();
        frame.setTitle("ABC");
        frame.setLocationByPlatform(true);
        frame.setSize(300, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);

        try {
            Thread.sleep(10_000); //sleep for 10 seconds
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        
        frame.setTitle("XYZ");
    }

}

Answer 1

To achieve your goal, you can use the Timer class of Swing:

timer = new Timer( 1500, e -> {
   panel.setBackground( Color.darkGray );
   frame.setTitle( "XYZ" );
   timer.stop();
} );
timer.setInitialDelay( 3500 );
timer.setRepeats( false );
timer.start();

As you can see, the implementation is very simple, first we instantiate the Timer:

timer = new Timer(

as parameters we pass it the time between repetitions (although in this case they are not used):

1500,

and a lamba (abstract class) that will execute the code:

e -> {

inside it, we place the code to execute, and as we don't need repetitions, we call timer.stop(), to stop its execution.

   panel.setBackground( Color.darkGray );
   frame.setTitle( "XYZ" );
   timer.stop();
} );

All that's left is to finish setting the timer, and start it. We indicate the time from the beginning to the first execution:

timer.setInitialDelay( 3500 );

We indicate that we do not want repetitions:

timer.setRepeats( false );

We start it:

timer.start();

import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;  // not "java.util.Timer"

public class cry {
   Timer timer;
   JPanel panel;
   JFrame frame;

   public static void main( String[] args ) {
      Cry cry = new Cry();
      SwingUtilities.invokeLater( cry :: blah );
   }

   private void blah() {
      frame = new JFrame();
      frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
      frame.setLocationByPlatform( true );
      frame.setSize( 300, 300 );
      frame.setTitle( "ABC" );
      panel = new JPanel();
      panel.setBackground( Color.red );
      panel.setSize( 300, 300 );
      frame.add( panel );
      frame.setVisible( true );
      timer = new Timer( 1500, e -> {
         panel.setBackground( Color.darkGray );
         frame.setTitle( "XYZ" );
         timer.stop();
      } );
      timer.setInitialDelay( 3500 );
      timer.setRepeats( false );
      timer.start();
   }
}

Note: you will have noticed that I separated the declaration of frame, putting this in the body of the class, and the instantiation inside blah, this is necessary, because the call to timer.stop(), is inside a lambda, that is to say inside an internal class, from that place, only the attributes of the parent class can be "seen".