Java EDT与后台工作线程的并发处理方案咨询

你的核心需求是：后台线程计算数据时，GUI可以安全使用旧数据重绘，但绝对不能读取到数据的中间修改状态，同时要避免EDT被阻塞。这类问题的通用解决方案围绕避免共享可变数据的中间态暴露展开，以下是几种可靠的实现方式：

1. 不可变数据对象（最优方案） #

把Data类设计成不可变对象——所有属性用final修饰，仅提供getter方法，不允许任何修改操作。后台线程计算时，直接创建全新的Data实例，计算完成后再替换GUI中的数据引用。

修改后的代码示例： #

不可变的Data类

public final class Data {
    private final int value1;
    private final String value2;
    // 所有业务属性都声明为final

    // 仅通过构造器初始化所有属性
    public Data(int value1, String value2) {
        this.value1 = value1;
        this.value2 = value2;
    }

    // 仅提供只读的getter方法
    public int getValue1() { return value1; }
    public String getValue2() { return value2; }
}

优化后的CustomPanel

public class CustomPanel extends JPanel implements MouseListener {
    // 用volatile保证引用的多线程可见性
    private volatile Data dataReference;

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        // 先获取当前引用，避免绘制过程中引用被替换
        Data currentData = dataReference;
        if (currentData != null) {
            // 使用完整的currentData绘制，不会读到中间态
            g.drawString("数值1: " + currentData.getValue1(), 10, 30);
            g.drawString("文本2: " + currentData.getValue2(), 10, 50);
        }
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        // 传递panel引用给SwingWorker，同时用execute()启动后台线程（不要直接调用doInBackground）
        new CustomSwingWorker(this).execute();
    }

    // 更新数据引用，无需同步，因为引用赋值是原子操作
    public void updateData(Data newData) {
        this.dataReference = newData;
    }
}

优化后的CustomSwingWorker

public class CustomSwingWorker extends SwingWorker<Void, Void> {
    private final CustomPanel targetPanel;

    public CustomSwingWorker(CustomPanel panel) {
        this.targetPanel = panel;
    }

    @Override
    protected Void doInBackground() throws Exception {
        // 在后台线程计算全新的Data实例
        Data newCalculatedData = performLongCalculation();
        // 替换数据引用
        targetPanel.updateData(newCalculatedData);
        return null;
    }

    @Override
    protected void done() {
        // 通知GUI重绘
        targetPanel.repaint();
    }

    // 模拟耗时计算
    private Data performLongCalculation() {
        // 这里写你的业务计算逻辑，返回新的Data实例
        try {
            Thread.sleep(2000); // 模拟耗时操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return new Data(100, "后台计算完成");
    }
}

原理说明： #

• 不可变对象的状态一旦创建就无法修改，EDT读取的永远是完整、一致的实例
• volatile修饰保证dataReference的更新能被EDT立即感知到
• 引用赋值是原子操作，不会出现"半更新"的情况，EDT要么读到旧实例，要么读到新实例，完全避免中间态

2. 使用原子引用（AtomicReference） #

如果Data类无法修改为不可变（比如已有大量代码依赖），可以用AtomicReference来存储Data实例，本质和不可变对象方案逻辑一致：后台线程修改副本，完成后用原子操作替换引用。

代码示例： #

public class CustomPanel extends JPanel implements MouseListener {
    private final AtomicReference<Data> dataReference = new AtomicReference<>();

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        Data currentData = dataReference.get();
        if (currentData != null) {
            // 使用currentData绘制
        }
    }

    public void updateData(Data newData) {
        dataReference.set(newData);
    }
}

原理说明： #

AtomicReference的get()和set()方法都是原子且可见的，保证EDT读取的实例要么是旧的完整状态，要么是新的完整状态，不会访问到中间修改的对象。

3. 读写分离的快照模式 #

如果必须在原有Data对象上修改属性，可以采用"快照"思路：

1. 后台线程先复制一份当前Data的快照（完整拷贝）
2. 在快照副本上执行所有修改操作
3. 修改完成后，替换GUI中的Data引用

这种方式同样能保证EDT永远不会访问到正在修改的实例，只会读取到完整的旧快照或新快照。

核心原则总结 #

• 绝对禁止后台线程直接修改EDT正在使用的共享数据实例，必须通过替换整个实例的方式更新数据
• 保证数据实例的引用更新是原子且可见的（用volatile或AtomicReference）
• 优先使用不可变数据对象，从根源上避免中间状态的问题

内容的提问来源于stack exchange，提问作者my_dear_doctor