Java中Graphics2D渲染自定义矩形过慢的原因求助

我正在开发一个可修改角度、填充色、线条颜色及粗细的矩形类，需按该样式渲染。测试时发现矩形渲染速度过慢，能明显看到从上到下的绘制过程，请问可能的原因是什么？

代码文件 #

GEdit.java #

import javax.swing.*; 
public class GEdit { 
    public static void main(String[] args) { 
        frame app = new frame(); 
        app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        app.setSize(1000,1000); 
        app.setVisible(true); 
    } 
}

Figure.java #

import java.awt.*; 
import java.awt.geom.Point2D; 
public abstract class Figure { 
    public static final int TOPLEFT = 0; 
    public static final int TOPCENTER = 1; 
    public static final int TOPRIGHT = 2; 
    public static final int CENTERLEFT = 3; 
    public static final int CENTER = 4; 
    public static final int CENTERRIGHT = 5; 
    public static final int BOTTOMLEFT = 6; 
    public static final int BOTTOMCENTER = 7; 
    public static final int BOTTOMRIGHT = 8; 
    private boolean fill_able; 
    private int fill_option; 
    private Color fill_color; 
    private int fill_transparency; 
    private Color line_color; 
    private float line_thickness; 
    private int line_transparency; 
    private int width; 
    private int height; 
    private float rotate_angle; 
    private boolean width_height_ratio_fixed; 
    private Point location; 
    private int base; 

    public Figure(boolean fill_able, int fill_option, Color fill_color, int fill_transparency, Color line_color, float line_thickness, int line_transparency, int width, int height, float rotate_angle, boolean width_height_ratio_fixed, int x, int y, int base) { 
        this.fill_able = fill_able; 
        this.fill_option = fill_option; 
        this.fill_color = fill_color; 
        this.fill_transparency = fill_transparency; 
        this.line_color = line_color; 
        this.line_thickness = line_thickness; 
        this.line_transparency = line_transparency; 
        this.width = width; 
        this.height = height; 
        this.rotate_angle = rotate_angle; 
        this.width_height_ratio_fixed = width_height_ratio_fixed; 
        this.location = new Point(x,y); 
        this.base = base; 
    } 

    public boolean is_fill_able() { return fill_able; } 
    public int get_fill_option() { return fill_option; } 
    public Color get_fill_color() { return fill_color; } 
    public int get_fill_transparency() { return fill_transparency; } 
    public Color get_line_color() { return line_color; } 
    public float get_line_thickness() { return line_thickness; } 
    public int get_line_transparency() { return line_transparency; } 
    public int get_width() { return width; } 
    public int get_height() { return height; } 
    public float get_rotate_angle() { return rotate_angle; } 
    public boolean is_width_height_ratio_fixed() { return width_height_ratio_fixed; } 
    public Point get_location() { return location; } 

    public Point get_render_location() { 
        int x, y; 
        switch(base) { 
            case TOPLEFT: x = location.x; y = location.y; break; 
            case TOPCENTER: x = location.x - (int)Math.round(width / 2); y = location.y; break; 
            case TOPRIGHT: x = location.x - width; y = location.y; break; 
            case CENTERLEFT: x = location.x; y = location.y - (int)Math.round(height / 2); break; 
            case CENTER: x = location.x - (int)Math.round(width / 2); y = location.y - (int)Math.round(height / 2); break; 
            case CENTERRIGHT: x = location.x - width; y = location.y - (int)Math.round(height / 2); break; 
            case BOTTOMLEFT: x = location.x; y = location.y - height; break; 
            case BOTTOMCENTER: x = location.x - (int)Math.round(width / 2); y = location.y - height; break; 
            case BOTTOMRIGHT: x = location.x - width; y = location.y - height; break; 
            default: x = 0; y = 0; break; 
        } 
        return new Point(x, y); 
    } 

    public int get_base() { return base; } 

    public void set_fill_option(int option) { this.fill_option = option; } 
    public void set_fill_color(Color color) { this.fill_color = color; } 
    public void set_fill_transparency(int transparency) { this.fill_transparency = transparency; } 
    public void set_line_color(Color color) { this.line_color = color; } 
    public void set_line_transparency(int transparency) { this.line_transparency = transparency; } 

    public void set_width(int width) { 
        if(this.width_height_ratio_fixed) { 
            float ratio = this.height / this.width; 
            this.width = width; 
            this.height = (int)Math.round(width * ratio); 
        } else { this.width = width;} 
    } 

    public void set_height(int height) { 
        if(this.width_height_ratio_fixed) { 
            float ratio = this.width / this.height; 
            this.height = height; 
            this.width = (int)Math.round(height * ratio); 
        } else{ this.height = height;} 
    } 

    public void set_rotate_angle(float angle) { 
        if(angle > 360) { this.rotate_angle = angle % 360; } 
        else this.rotate_angle = angle; 
    } 

    public void set_location(int x, int y) { this.location.setLocation(x, y); } 
    public void set_location(Point location) { this.location = location; } 
    public void set_base(int base) { this.base = base; } 

    abstract public void render(Graphics2D g); 
}

Rectangle.java #

import java.awt.*; 
import java.awt.Graphic

可能的原因及解决方案 #

我来帮你分析下几种最可能导致渲染卡顿、出现从上到下绘制过程的原因，以及对应的解决办法：

• 未启用双缓冲（Double Buffering）
  Swing部分组件默认支持双缓冲，但如果你的自定义渲染逻辑直接在paint方法中操作，或者自定义的frame类没有正确开启双缓冲，就会出现画面逐行刷新的“撕裂”感。双缓冲是先在内存中绘制完整画面，再一次性输出到屏幕，能彻底避免这种可见的绘制过程。
  解决办法：如果是自定义JComponent子类，务必重写paintComponent而非paint，并通过setDoubleBuffered(true)显式开启双缓冲；顶层窗口也可以在初始化时配置双缓冲属性。

• 渲染逻辑阻塞事件调度线程（EDT）
  如果你的render方法包含大量重复计算（比如坐标转换、透明度计算），或者在EDT中执行了其他耗时任务，会直接阻塞UI线程，导致画面刷新不流畅。EDT负责所有UI事件和渲染操作，一旦被阻塞，就会出现明显的绘制延迟。
  解决办法：把非UI的计算逻辑（比如角度转换、坐标预计算）放到后台线程完成，只将最终的绘制数据传递给EDT进行渲染；提前缓存旋转后的Shape对象、带透明度的Color对象，避免每次渲染都重复计算。

• Graphics2D渲染设置未优化
  比如未开启硬件加速，或者使用了低效的绘制方式。例如手动逐像素填充矩形、每次渲染都重新创建Color对象处理透明度，都会大幅增加开销。
  解决办法：

  1. 使用Graphics2D.create()创建临时上下文，设置好抗锯齿、透明度等属性后再绘制，避免污染全局上下文；
  2. 提前创建并缓存带透明度的Color对象（如new Color(r,g,b,alpha)），不要每次渲染都重新计算；
  3. 使用Rectangle2D等Shape对象绘制，Java2D对Shape的绘制做了深度优化，比手动绘制线条和填充高效得多；
  4. 启用硬件加速：通过System.setProperty("sun.java2d.opengl", "true")开启OpenGL加速，提升渲染性能。

• 重绘机制不合理
  如果每次重绘都触发整个窗口的刷新（比如调用无参的repaint()），而不是只刷新矩形所在的区域，会导致不必要的渲染开销，尤其是你的窗口尺寸达到1000x1000时。
  解决办法：调用repaint(x,y,width,height)指定需要重绘的区域，只刷新矩形的边界范围，减少渲染工作量。

• Rectangle类的render方法实现低效
  从你提供的不完整代码来看，Rectangle.java的渲染逻辑可能存在问题。比如手动绘制四条边、逐行填充，或者没有正确使用旋转后的Shape，都会导致速度变慢。建议优化render方法如下：

  @Override
  public void render(Graphics2D g) {
      Point renderLoc = get_render_location();
      // 创建基础矩形Shape
      Rectangle2D rect = new Rectangle2D.Double(renderLoc.x, renderLoc.y, get_width(), get_height());
      // 应用旋转变换
      AffineTransform transform = AffineTransform.getRotateInstance(
          Math.toRadians(get_rotate_angle()), 
          renderLoc.x + get_width()/2, 
          renderLoc.y + get_height()/2
      );
      Shape rotatedRect = transform.createTransformedShape(rect);
      
      // 填充矩形（处理透明度）
      g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, get_fill_transparency()/255f));
      g.setColor(get_fill_color());
      g.fill(rotatedRect);
      
      // 绘制边框（处理透明度和线条粗细）
      g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, get_line_transparency()/255f));
      g.setColor(get_line_color());
      g.setStroke(new BasicStroke(get_line_thickness()));
      g.draw(rotatedRect);
  }
  

  这种方式利用Java2D的优化Shape绘制，比手动实现高效得多。

内容的提问来源于stack exchange，提问作者Inyoung Kim 김인영