SwingWorker, Thread.sleep(), or javax.swing.timer? I need to “insert a pause”

Use javax.swing.Timer to schedule a future event to trigger. This will allow you to make changes to the UI safely, as the timer is triggered within the context of the Event Dispatching Thread.

The problem with been able to flip multiple cards simultaneously has more to do with you not setting up a state that prevents the user from flipping cards then the use of timers.

The following example basically only allows one card to be flipped per group at a time.

Once a card has been flipped in both groups, the timer is started. When it is triggered, the cards are reset.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.LinearGradientPaint;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.border.LineBorder;

public class FlipCards {

    public static void main(String[] args) {
        new FlipCards();
    }

    public FlipCards() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class Card extends JPanel {

        private BufferedImage image;
        private boolean flipped = false;

        private Dimension prefSize;

        public Card(BufferedImage image, Dimension prefSize) {
            setBorder(new LineBorder(Color.DARK_GRAY));
            this.image = image;
            this.prefSize = prefSize;
        }

        @Override
        public Dimension getPreferredSize() {
            return prefSize;
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            LinearGradientPaint lgp = new LinearGradientPaint(
                    new Point(0, 0),
                    new Point(0, getHeight()),
                    new float[]{0f, 1f},
                    new Color[]{Color.WHITE, Color.GRAY});
            g2d.setPaint(lgp);
            g2d.fill(new Rectangle(0, 0, getWidth(), getHeight()));
            if (flipped && image != null) {
                int x = (getWidth() - image.getWidth()) / 2;
                int y = (getHeight() - image.getHeight()) / 2;
                g2d.drawImage(image, x, y, this);
            }
            g2d.dispose();
        }

        public void setFlipped(boolean flipped) {

            this.flipped = flipped;
            repaint();

        }
    }

    public class CardsPane extends JPanel {

        private Card flippedCard = null;

        public CardsPane(List<BufferedImage> images, Dimension prefSize) {
            setLayout(new GridBagLayout());
            MouseAdapter mouseHandler = new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    if (flippedCard == null) {
                        Card card = (Card) e.getComponent();
                        card.setFlipped(true);
                        flippedCard = card;
                        firePropertyChange("flippedCard", null, card);
                    }
                }
            };
            GridBagConstraints gbc = new GridBagConstraints();
            gbc.insets = new Insets(4, 4, 4, 4);
            gbc.fill = GridBagConstraints.BOTH;
            gbc.weightx = 0.25f;
            for (BufferedImage img : images) {
                Card card = new Card(img, prefSize);
                card.addMouseListener(mouseHandler);
                add(card, gbc);
            }
        }

        public Card getFlippedCard() {
            return flippedCard;
        }

        public void reset() {
            if (flippedCard != null) {
                flippedCard.setFlipped(false);
                flippedCard = null;
            }
        }
    }

    public class TestPane extends JPanel {

        private CardsPane topCards;
        private CardsPane bottomCards;

        private Timer resetTimer;

        public TestPane() {

            resetTimer = new Timer(1000, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    topCards.reset();
                    bottomCards.reset();
                }
            });
            resetTimer.setRepeats(false);
            resetTimer.setCoalesce(true);

            PropertyChangeListener propertyChangeHandler = new PropertyChangeListener() {
                @Override
                public void propertyChange(PropertyChangeEvent evt) {
                    Card top = topCards.getFlippedCard();
                    Card bottom = bottomCards.getFlippedCard();
                    if (top != null && bottom != null) {
                        resetTimer.start();
                    }
                }
            };
            BufferedImage[] images = new BufferedImage[4];
            try {
                images[0] = ImageIO.read(new File("./Card01.png"));
                images[1] = ImageIO.read(new File("./Card02.jpg"));
                images[2] = ImageIO.read(new File("./Card03.jpg"));
                images[3] = ImageIO.read(new File("./Card04.png"));

                Dimension prefSize = getMaxBounds(images);

                List<BufferedImage> topImages = new ArrayList<>(Arrays.asList(images));
                Random rnd = new Random(System.currentTimeMillis());
                int rotate = (int) Math.round((rnd.nextFloat() * 200) - 50);
                Collections.rotate(topImages, rotate);
                topCards = new CardsPane(topImages, prefSize);
                topCards.addPropertyChangeListener("flippedCard", propertyChangeHandler);

                List<BufferedImage> botImages = new ArrayList<>(Arrays.asList(images));

                int botRotate = (int) Math.round((rnd.nextFloat() * 200) - 50);
                Collections.rotate(botImages, botRotate);
                bottomCards = new CardsPane(botImages, prefSize);
                bottomCards.addPropertyChangeListener("flippedCard", propertyChangeHandler);

                setLayout(new GridBagLayout());
                GridBagConstraints gbc = new GridBagConstraints();
                gbc.insets = new Insets(4, 4, 4, 4);
                gbc.gridwidth = GridBagConstraints.REMAINDER;
                add(topCards, gbc);
                add(bottomCards, gbc);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        protected Dimension getMaxBounds(BufferedImage[] images) {
            int width = 0;
            int height = 0;

            for (BufferedImage img : images) {
                width = Math.max(width, img.getWidth());
                height = Math.max(height, img.getHeight());
            }

            return new Dimension(width, height);
        }
    }
}