Java中跨类变量共享与进度更新的策略

本文深入探讨了在java中实现不同运行类之间变量共享和进度更新的多种策略。针对文件复制等耗时操作的进度显示需求，文章介绍了基于回调的观察者模式、基于拉取的迭代器模式以及多线程环境下安全共享变量的方法。通过具体代码示例，详细阐述了如何设计类间通信机制，确保数据一致性和系统可维护性，并提供了在并发编程中处理共享状态的最佳实践。

在Java应用程序开发中，尤其是在处理如文件复制、数据处理或网络传输等耗时操作时，一个常见的需求是在一个类中执行任务，并在另一个类（例如用户界面类）中实时显示任务的进度。直接通过静态变量进行简单的读写操作，虽然在某些简单场景下可行，但在多线程环境或需要更灵活的通知机制时，往往会导致数据不一致、难以维护甚至出现竞态条件等问题。本教程将介绍几种更健壮、更符合面向对象设计原则的解决方案。

一、基于回调的观察者模式：任务执行者通知进度显示者

这种方法的核心思想是让执行任务的类（Subject，例如文件复制类）持有进度显示类（Observer）的实例。当任务执行过程中有新的进度时，Subject会主动调用Observer类中的特定方法来更新进度。这是一种经典的观察者模式应用，实现了任务执行者与进度显示者之间的松耦合。

1. 工作原理

任务执行者 (Subject)：负责执行实际的耗时操作。它在构造函数或通过setter方法接收一个或多个进度显示者（Observer）的实例。在每次完成一个阶段的任务后，它会调用Observer实例的通知方法，传递当前的进度信息。进度显示者 (Observer)：负责接收并显示进度信息。它提供一个公共方法，供Subject调用以更新其内部状态或显示界面。

2. 代码示例

假设我们有一个FileCopier类负责复制文件，一个ProgressMonitor类负责显示进度。

// ProgressMonitor.java - 进度显示者public class ProgressMonitor {    /**     * 更新进度的方法     * @param current 当前已完成的块数     * @param total 总块数     */    public void updateProgress(long current, long total) {        System.out.println("进度: " + current + "/" + total + " (" + (current * 100 / total) + "%)");        // 实际应用中，这里可能是更新UI组件，例如JProgressBar    }}// FileCopier.java - 任务执行者public class FileCopier {    private final long totalBlocks;    private ProgressMonitor monitor; // 持有进度显示者的引用    /**     * 构造函数，初始化总块数并接收进度显示者     * @param totalBlocks 待复制文件的总块数     * @param monitor 进度显示器实例     */    public FileCopier(long totalBlocks, ProgressMonitor monitor) {        this.totalBlocks = totalBlocks;        this.monitor = monitor;    }    /**     * 模拟文件复制过程     */    public void startCopy() {        for (long current = 1; current <= totalBlocks; current++) {            // 模拟每个块的复制耗时            try {                Thread.sleep(100); // 暂停100毫秒            } catch (InterruptedException e) {                Thread.currentThread().interrupt();                System.err.println("文件复制中断。");                return;            }            // 通知进度显示者更新进度            if (monitor != null) {                monitor.updateProgress(current, totalBlocks);            }        }        System.out.println("文件复制完成！");    }}// MainApp.java - 主应用类public class MainApp {    public static void main(String[] args) {        long totalBlocks = 50; // 假设文件有50个块        ProgressMonitor monitor = new ProgressMonitor();        FileCopier copier = new FileCopier(totalBlocks, monitor);        copier.startCopy();    }}

3. 注意事项

这种方法适用于任务执行者在主线程中运行，并且进度更新也发生在同一线程的场景。如果任务执行者在一个单独的线程中运行，而进度显示者需要更新UI（通常在UI线程），则需要额外的机制来确保线程安全地更新UI，例如使用SwingUtilities.invokeLater()或Platform.runLater()。

二、基于拉取的迭代器模式：进度显示者主动查询

与观察者模式相反，这种方法让进度显示者（Observer）主动地从任务执行者（Subject）那里“拉取”进度信息。进度显示者通过循环不断查询任务执行者的状态，直到任务完成。

立即学习“Java免费学习笔记（深入）”；

绘蛙AI修图

绘蛙平台AI修图工具，支持手脚修复、商品重绘、AI扩图、AI换色

285 查看详情

1. 工作原理

任务执行者 (Subject)：负责执行实际操作，并提供方法让外部查询其当前进度和是否已完成。进度显示者 (Observer)：在自己的循环中，持有Subject的实例，并周期性地调用Subject提供的方法来获取进度信息。

2. 代码示例

// FileCopierPull.java - 任务执行者（提供拉取接口）public class FileCopierPull {    private final long totalBlocks;    private long currentBlock = 0; // 当前已完成的块数    private volatile boolean finished = false; // 标记任务是否完成    public FileCopierPull(long totalBlocks) {        this.totalBlocks = totalBlocks;    }    /**     * 模拟复制下一个块     * @return 如果还有更多块待复制，返回true；否则返回false     */    public boolean copyNextBlock() {        if (currentBlock < totalBlocks) {            currentBlock++;            // 模拟复制耗时            try {                Thread.sleep(100);            } catch (InterruptedException e) {                Thread.currentThread().interrupt();                System.err.println("文件复制中断。");                finished = true; // 任务中断也视为结束                return false;            }            if (currentBlock == totalBlocks) {                finished = true;            }            return true;        } else {            finished = true;            return false;        }    }    public long getCurrentBlock() {        return currentBlock;    }    public long getTotalBlocks() {        return totalBlocks;    }    public boolean isFinished() {        return finished;    }}// ProgressMonitorPull.java - 进度显示者（主动拉取）public class ProgressMonitorPull {    private FileCopierPull copier;    public ProgressMonitorPull(FileCopierPull copier) {        this.copier = copier;    }    /**     * 启动进度监控     */    public void startMonitoring() {        while (!copier.isFinished()) {            // 模拟复制一个块，并获取最新进度            // 注意：这里让monitor来驱动copyNextBlock，这可能不是最佳实践，            // 更常见的是copier在自己的线程中运行，monitor只是查询其状态。            // 为了匹配原答案的“Observer controls”的含义，我们暂时这样设计。            // 实际应用中，copier会自己调用copyNextBlock，monitor只负责查询getCurrentBlock。            // 假设copier已经在后台运行并更新其内部状态。            // 为了示例，我们在这里手动驱动它。            if (copier.copyNextBlock()) { // 每次查询都推进一步                System.out.println("进度: " + copier.getCurrentBlock() + "/" + copier.getTotalBlocks() +                        " (" + (copier.getCurrentBlock() * 100 / copier.getTotalBlocks()) + "%)");            } else {                break; // 任务已完成或中断            }            try {                Thread.sleep(50); // 避免忙等待，周期性查询            } catch (InterruptedException e) {                Thread.currentThread().interrupt();                System.err.println("进度监控中断。");                break;            }        }        System.out.println("文件复制完成！");    }}// MainAppPull.java - 主应用类public class MainAppPull {    public static void main(String[] args) {        long totalBlocks = 50;        FileCopierPull copier = new FileCopierPull(totalBlocks);        ProgressMonitorPull monitor = new ProgressMonitorPull(copier);        monitor.startMonitoring();    }}

3. 注意事项

此模式下，如果任务执行者和进度显示者在同一线程中运行，进度显示者的循环会阻塞主线程。如果任务执行者在单独线程中运行，进度显示者也应在单独线程中运行，并周期性查询。为了避免“忙等待”（即无限循环地查询而不进行任何暂停），查询线程应该使用Thread.sleep()或更高级的并发工具进行适当的暂停。任务执行者中的进度变量（如currentBlock和finished）在多线程环境下需要确保可见性，通常使用volatile关键字或synchronized块。

三、多线程环境下的变量共享与进度更新

在实际应用中，耗时操作通常会在一个独立的后台线程中执行，以避免阻塞用户界面。此时，安全地共享变量并更新进度变得尤为重要，需要考虑线程安全和内存可见性问题。

1. 工作原理

任务线程：负责执行耗时操作，并在其内部维护当前的进度状态。监控线程（或UI线程）：周期性地从任务线程中读取进度状态并显示。关键：确保任务线程对进度变量的写入对监控线程是可见的，并且读取是线程安全的。

2. 核心概念与解决方案

volatile 关键字：用于确保变量的内存可见性。当一个变量被声明为volatile时，任何对它的写入都会立即刷新到主内存，任何对它的读取都会从主内存中获取最新值，从而避免了线程缓存导致的数据不一致问题。它适用于单个变量的简单读写操作。synchronized 关键字：提供互斥访问，确保在同一时间只有一个线程可以执行被synchronized修饰的代码块或方法。它不仅保证了可见性，还保证了原子性。java.util.concurrent.atomic 包：提供了原子操作类，如AtomicLong、AtomicInteger等，可以在不使用synchronized的情况下，以原子方式更新变量，效率更高。ExecutorService 和 Future：更高级的并发管理工具，可以提交任务并获取任务执行结果，包括进度。UI框架提供的并发工具：如Java Swing的SwingWorker、JavaFX的javafx.concurrent包，它们专门设计用于在后台线程执行任务并安全地更新UI线程。

3. 代码示例：使用 volatile 和独立线程

import java.util.concurrent.TimeUnit;// BackgroundCopier.java - 后台文件复制任务public class BackgroundCopier implements Runnable {    private final long totalBlocks;    private volatile long currentBlock = 0; // 使用 volatile 确保可见性    private volatile boolean cancelled = false; // 任务取消标记    private volatile boolean finished = false; // 任务完成标记    public BackgroundCopier(long totalBlocks) {        this.totalBlocks = totalBlocks;    }    @Override    public void run() {        System.out.println("文件复制任务启动...");        for (long i = 1; i  0) { // 避免除以零                System.out.println("[监控] 进度: " + current + "/" + total + " (" + (current * 100 / total) + "%)");            } else {                System.out.println("[监控] 进度: " + current + "/" + total);            }            try {                TimeUnit.MILLISECONDS.sleep(200); // 每200毫秒查询一次进度            } catch (InterruptedException e) {                Thread.currentThread().interrupt();                System.err.println("进度监控器被中断。");                break;            }        }        System.out.println("进度监控器停止。");    }    public void stop() {        stopMonitoring = true;    }}// MainAppMultiThread.java - 主应用类public class MainAppMultiThread {    public static void main(String[] args) throws InterruptedException {        long totalBlocks = 50;        BackgroundCopier copierTask = new BackgroundCopier(totalBlocks);        Thread copierThread = new Thread(copierTask, "FileCopierThread");        ProgressDisplayThread displayTask = new ProgressDisplayThread(copierTask);        Thread displayThread = new Thread(displayTask, "ProgressDisplayThread");        copierThread.start(); // 启动文件复制线程        displayThread.start(); // 启动进度显示线程        // 等待文件复制线程完成        copierThread.join();        // 通知进度显示线程停止监控        displayTask.stop();        displayThread.join(); // 等待进度显示线程停止        System.out.println("所有任务完成。");    }}

4. 注意事项

线程安全：当多个线程访问和修改同一个共享变量时，必须确保操作的原子性、可见性和有序性。volatile确保可见性，但不能保证原子性（例如currentBlock++不是原子操作）。对于简单的计数器，volatile通常足够，但更复杂的复合操作（如先检查再修改）则需要synchronized或Atomic*类。避免忙等待：进度显示线程不应无限循环查询，而应设置适当的sleep时间，以减少CPU占用。UI更新：如果进度需要更新UI组件，务必在UI线程中进行。使用SwingWorker或javafx.concurrent是处理Java桌面应用中后台任务和UI更新的最佳实践。

总结与最佳实践

选择哪种方法取决于具体的应用场景和对并发的需求：

单线程简单场景：如果任务和进度显示都在同一个线程中执行，或者任务执行者能直接调用进度显示者的方法，那么基于回调的观察者模式是简洁有效的选择。单线程主动查询场景：如果进度显示者需要更强的控制权，主动决定何时查询进度，且任务和显示都在同一线程，基于拉取的迭代器模式可行，但需注意避免阻塞。多线程并发场景：这是最常见的实际需求。对于简单的共享变量（如进度计数），使用volatile关键字可以确保可见性。对于需要原子性操作的共享变量，考虑使用java.util.concurrent.atomic包中的类。对于更复杂的同步需求，synchronized关键字是必不可少的。在Java桌面应用中，强烈推荐使用SwingWorker (Swing) 或 javafx.concurrent (JavaFX)，它们提供了优雅的机制来在后台线程执行任务并安全地更新UI线程。

无论选择哪种方法，良好的代码设计都应遵循职责分离原则，让任务执行者专注于任务本身，而进度显示者专注于显示。通过接口或抽象类来定义通信契约，可以进一步提高代码的灵活性和可维护性。

以上就是Java中跨类变量共享与进度更新的策略的详细内容，更多请关注创想鸟其它相关文章！