将 repaint() 与 Thread.Sleep() 结合起来

Question

我想做的事情非常简单，我想在屏幕上显示算法的步骤，因此为什么我尝试将 repaint() 与 sleep() 结合起来，但我做错了，如果有人足够了解，我会喜欢它首先解释一下这段代码有什么问题，其次，我该怎么做才能让它工作......

谢谢！

在夏天，这段代码的目的是绘制 10 个红色顶点，然后以 200 毫秒的间隔将它们一一涂黑。

这是代码：

public class Tester {

       public static void main(String[] args) {
            SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    ShowGUIGraph();
                }
            });
        }

        private static void ShowGUIGraph() {
            JFrame f = new JFrame("something");
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            JPanel p=new JPanel();
            p.setLayout(new BorderLayout());
            p.add(BorderLayout.CENTER,new SomePanel());
            f.add(p);
            f.setPreferredSize(new Dimension(800,600));
            f.pack();
            f.setVisible(true);
        }
}

public class SomePanel extends JPanel {
    private static final long serialVersionUID = 1L;
    LinkedList<Vertex> vertices=new LinkedList<Vertex>();
    public SomePanel () {
        for (int i=0;i<10;i++) {
            Vertex v=new Vertex(i);
            v.setLocation(20+30*i, 20+30*i);
            vertices.add(v);
        }
        traverseVerticesRecoursive(0);
        traverseVerticesNonRecoursive();
    }
    public void traverseVerticesRecoursive(int i) {
        if (i>=vertices.size()) return;
        vertices.get(i).setColor(Color.black);

        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        repaint();
        traverseVerticesRecoursive(i+1);
    }
    public void traverseVerticesNonRecoursive() {
        for (int i=0;i<10;i++) {
            vertices.get(i).setColor(Color.red);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            repaint();
        }
    }
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        for (int i=0;i<vertices.size();i++) {
            vertices.get(i).paintVertex(g);
        }

    }
}
   public class Vertex {
        private int x,y,tag,r=20;
        private Color color=Color.red;
        Vertex (int i) {
            tag=i;
        }
        public void setLocation(int x0,int y0) {
            x=x0;
            y=y0;
        }
        public int getX() {
            return x;
        }
        public int getY() {
            return y;
        }

        public void setColor(Color c) {
            color=c;
        }
        public boolean colorIs(Color c) {
            return (color.equals(c));
        }

        public void paintVertex(Graphics g) {
            g.setColor(color);
            g.fillOval(x,y,r,r);
            g.setColor(Color.BLACK);
            g.drawOval(x,y,r,r);
            g.drawString(""+tag, x+r/2, y+r/2+4);
        }
        public int getR() {
            return r;
        }
    }

Answer 1

不要在事件派发线程中休眠；这将导致 GUI 冻结。对于动画，请使用 EDT 友好的实用程序类，例如 javax.swing.Timer。

Answer 2

一些可能使您的代码更简洁的想法：

1. 在您的 SomePanel 类中，将遍历代码放在构造函数之外的方法中。构造函数用于初始化字段。
2. 首先启动静态 GUI，然后生成一个工作线程以通过前面的方法进行更新（这将是您的小型“引擎”）。在此线程中，您可以调用sleep。
3. 在 traverseVerticesRecoursive 方法中，仅在 UI 线程上进行重绘，并在工作线程上进行状态更新。

您应该做的主要修改是不要通过睡眠调用来阻止 GUI 线程，正如他们在第一个答案中告诉您的那样。

Answer 3

Thread.sleep 是一个长时间运行的任务。当您在 EDT 中运行此类任务时，它会阻止执行所有重绘请求。所有待处理的重绘请求和在睡眠阶段发送的重绘请求都会排队等待将来处理。

因此，当 EDT 退出睡眠阶段时，它会将所有此类重绘请求（如果启用了默认属性的合并）合并为一个要执行的重绘。如果未启用合并，则所有排队的请求都会串行执行，中间没有任何时间间隔。结果似乎 UI 没有更新。

要纠正这种情况，请使用计时器，该计时器会在特定时间间隔后定期触发。

Answer 4

伙计，你可以使用与 EDT 线程不同的新线程来制作动画。例如，

 void play() {
    Thread thread = new Thread() {
        @Override
        public void run() {
            game();
        }
    };
    thread.start();
}

void game() {
    for (; ; ) {
        switch (state) {
            case GameData.ANIMATING:
                // call some function as repaint() to update GUI
                break;
            case GameData.GAME_ENDED:
                return;
            default:
                break;
        }

        diffTime = System.currentTimeMillis() - beforeTime;
        sleepTime = delay - diffTime;
        sleepTime = (sleepTime < 0) ? 0 : sleepTime;
        Thread.sleep(sleepTime);
    }
}