Java 摆动速率限制

我有一个很长的重绘操作，我想限制它的速率，即确保最多每N毫秒调用一次

我目前的解决方案有些不尽如人意：我使用了一个持续时间很短的Swing

计时器，每当我得到一个事件时，我都会
restart（）
。这可确保在N毫秒窗口内发生事件时不会触发重新绘制（即，重新绘制将在事件发生且经过N毫秒“安静”期后进行）

我想要的是确保在第一个事件后最多N毫秒调用重新绘制，并且重新绘制周期最多为N。有什么想法吗？（在已经启动的
计时器上调用
start
的效果没有记录在案）。
我只知道来自本机操作系统的延迟，如果您将刷新率溢出，那么RepaitManager会出现错误，顺便说一句，您的主题非常学术化
延迟是每秒钟一个像素的最大刷新率

但是

或者另一个应该是测试的良好基础，直到重新绘制管理器出现第一个错误（然后可能锁定当前JVM实例）
源代码

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

public class AnimationBackground {

    public AnimationBackground() {
        Random random = new Random();
        JFrame frame = new JFrame("Animation Background");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.setLayout(new GridLayout(0, 1, 10, 10));
        //frame.setLayout(new GridLayout(0, 3, 10, 10));
        //for (int iPanels = 0; iPanels < 3; iPanels++) {
        for (int iPanels = 0; iPanels < 1; iPanels++) {
            final MyJPanel panel = new MyJPanel();
            panel.setBackground(Color.BLACK);
            for (int i = 0; i < 100; i++) {
                Star star = new Star(new Point(random.nextInt(490), random.nextInt(490)));
                star.setColor(new Color(100 + random.nextInt(155), 100 + random.nextInt(155), 100 + random.nextInt(155)));
                star.setxIncr(-3 + random.nextInt(7));
                star.setyIncr(-3 + random.nextInt(7));
                panel.add(star);
            }
            panel.setLayout(new GridLayout(10, 1));
            JLabel label = new JLabel("This is a Starry background.", JLabel.CENTER);
            label.setForeground(Color.WHITE);
            panel.add(label);
            JPanel stopPanel = new JPanel();
            stopPanel.setOpaque(false);
            stopPanel.add(new JButton(new AbstractAction("Stop this madness!!") {

                private static final long serialVersionUID = 1L;

                @Override
                public void actionPerformed(ActionEvent e) {
                    panel.stopAnimation();
                }
            }));
            panel.add(stopPanel);
            JPanel startPanel = new JPanel();
            startPanel.setOpaque(false);
            startPanel.add(new JButton(new AbstractAction("Start moving...") {

                private static final long serialVersionUID = 1L;

                @Override
                public void actionPerformed(ActionEvent e) {
                    panel.startAnimation();
                }
            }));
            panel.add(startPanel);
            frame.add(panel);
        }
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

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

            @Override
            public void run() {
                AnimationBackground animationBackground = new AnimationBackground();
            }
        });
    }

    class Star extends Polygon {

        private static final long serialVersionUID = 1L;
        private Point location = null;
        private Color color = Color.YELLOW;
        private int xIncr, yIncr;
        static final int WIDTH = 500, HEIGHT = 500;

        Star(Point location) {
            int x = location.x;
            int y = location.y;
            this.location = location;
            this.addPoint(x, y + 8);
            this.addPoint(x + 8, y + 8);
            this.addPoint(x + 11, y);
            this.addPoint(x + 14, y + 8);
            this.addPoint(x + 22, y + 8);
            this.addPoint(x + 17, y + 12);
            this.addPoint(x + 21, y + 20);
            this.addPoint(x + 11, y + 14);
            this.addPoint(x + 3, y + 20);
            this.addPoint(x + 6, y + 12);
        }

        public void setColor(Color color) {
            this.color = color;
        }

        public void move() {
            if (location.x < 0 || location.x > WIDTH) {
                xIncr = -xIncr;
            }
            if (location.y < 0 || location.y > WIDTH) {
                yIncr = -yIncr;
            }
            translate(xIncr, yIncr);
            location.setLocation(location.x + xIncr, location.y + yIncr);
        }

        public void setxIncr(int xIncr) {
            this.xIncr = xIncr;
        }

        public void setyIncr(int yIncr) {
            this.yIncr = yIncr;
        }

        public Color getColor() {
            return color;
        }
    }

    class MyJPanel extends JPanel {

        private static final long serialVersionUID = 1L;
        private ArrayList<Star> stars = new ArrayList<Star>();
        private Timer timer = new Timer(20, new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                for (Star star : stars) {
                    star.move();
                }
                repaint();
            }
        });

        public void stopAnimation() {
            if (timer.isRunning()) {
                timer.stop();
            }
        }

        public void startAnimation() {
            if (!timer.isRunning()) {
                timer.start();
            }
        }

        @Override
        public void addNotify() {
            super.addNotify();
            timer.start();
        }

        @Override
        public void removeNotify() {
            super.removeNotify();
            timer.stop();
        }

        MyJPanel() {
            this.setPreferredSize(new Dimension(520, 520));
        }

        public void add(Star star) {
            stars.add(star);
        }

        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            for (Star star : stars) {
                g.setColor(star.getColor());
                g.fillPolygon(star);
            }
        }
    }
}

import java.awt.*；
导入java.awt.event.*；
导入java.util.*；
导入javax.swing.*；
导入javax.swing.SwingUtilities；
导入javax.swing.Timer；
公共类动画背景{
公共动画背景（）{
随机=新随机（）；
JFrame=新的JFrame（“动画背景”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setresizeable（false）；
frame.setLayout（新的GridLayout（0,1,10,10））；
//frame.setLayout（新的GridLayout（0,3,10,10））；
//对于（int-iPanels=0；iPanels<3；iPanels++）{
对于（int-iPanels=0；iPanels<1；iPanels++）{
最终MyJPanel面板=新MyJPanel（）；
面板.立根背景（颜色.黑色）；
对于（int i=0；i<100；i++）{
星=新星（新点（random.nextInt（490），random.nextInt（490））；
star.setColor（新颜色（100+随机.nextInt（155），100+随机.nextInt（155），100+随机.nextInt（155））；
star.setxIncr（-3+random.nextInt（7））；
star.setyIncr（-3+random.nextInt（7））；
面板。添加（星形）；
}
panel.setLayout（新网格布局（10,1））；
JLabel label=newjlabel（“这是一个星光背景”，JLabel.CENTER）；
标签。设置前景（颜色。白色）；
面板。添加（标签）；
JPanel stopPanel=新的JPanel（）；
stopPanel.set不透明（假）；
add（新的JButton（新的抽象动作（“停止这种疯狂！！”）{
私有静态最终长serialVersionUID=1L；
@凌驾
已执行的公共无效操作（操作事件e）{
panel.stopAnimation（）；
}
}));
面板。添加（stopPanel）；
JPanel startPanel=新的JPanel（）；
startPanel.set不透明（假）；
添加（新的JButton（新的抽象操作（“开始移动…”））{
私有静态最终长serialVersionUID=1L；
@凌驾
已执行的公共无效操作（操作事件e）{
panel.startAnimation（）；
}
}));
面板。添加（startPanel）；
框架。添加（面板）；
}
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
公共静态void main（字符串[]args）{
SwingUtilities.invokeLater（新的Runnable（）{
@凌驾
公开募捐{
AnimationBackground AnimationBackground=新的AnimationBackground（）；
}
});
}
类星形延伸多边形{
私有静态最终长serialVersionUID=1L；
专用点位置=空；
私有颜色=Color.YELLOW；
私营企业国际新华社,银华社,；
静态最终整型宽度=500，高度=500；
星（点位置）{
int x=位置x；
int y=位置y；
这个位置=位置；
这个。添加点（x，y+8）；
这个。添加点（x+8，y+8）；
这个。添加点（x+11，y）；
此.添加点（x+14，y+8）；
这个。添加点（x+22，y+8）；
此.添加点（x+17，y+12）；
此.添加点（x+21，y+20）；
这个。添加点（x+11，y+14）；
此.添加点（x+3，y+20）；
这个。添加点（x+6，y+12）；
}
公共空间设置颜色（颜色）{
这个颜色=颜色；
}
公开作废动议（）{
如果（位置.x<0 | |位置.x>宽度）{
xIncr=-xIncr；
}
if（location.y<0 | | location.y>宽度）{
yIncr=-yIncr；
}
翻译（信、音）；
位置.setLocation（位置.x+xIncr，位置.y+yIncr）；
}
公共无效设置xIncr（int xIncr）{
this.xIncr=xIncr；
}
公共无效设置yIncr（int yIncr）{
this.yIncr=yIncr；
}
公共颜色getColor（）{
返回颜色；
}
}
类MyJPanel扩展了JPanel{
私有静态最终长serialVersionUID=1L；
private ArrayList stars=new ArrayList（）；
私有计时器=新计时器（20，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
对于（星星：星星）{
star.move（）；
}
重新油漆（）；
}
});
公共void stopAnimation（）{
if（timer.isRunning（））{
timer.stop（）；
}
}
公共无效开始生效（）{
如果（！timer.isRunning（））{
timer.sta