本文深入探讨了在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免费学习笔记（深入）”；
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 <= totalBlocks; i++) {
if (cancelled) {
System.out.println("文件复制任务已取消。");
break;
}
currentBlock = i; // 更新进度
try {
TimeUnit.MILLISECONDS.sleep(100); // 模拟每个块的复制耗时
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 重新设置中断状态
System.err.println("文件复制任务被中断。");
cancelled = true;
break;
}
}
finished = true;
if (!cancelled) {
System.out.println("文件复制任务完成！");
}
}
public long getCurrentBlock() {
return currentBlock;
}
public long getTotalBlocks() {
return totalBlocks;
}
public boolean isFinished() {
return finished;
}
public void cancel() {
cancelled = true;
}
}
// ProgressDisplayThread.java - 进度显示线程
public class ProgressDisplayThread implements Runnable {
private final BackgroundCopier copier;
private volatile boolean stopMonitoring = false;
public ProgressDisplayThread(BackgroundCopier copier) {
this.copier = copier;
}
@Override
public void run() {
System.out.println("进度监控器启动...");
while (!stopMonitoring && !copier.isFinished()) {
long current = copier.getCurrentBlock();
long total = copier.getTotalBlocks();
if (total > 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线程。
无论选择哪种方法，良好的代码设计都应遵循职责分离原则，让任务执行者专注于任务本身，而进度显示者专注于显示。通过接口或抽象类来定义通信契约，可以进一步提高代码的灵活性和可维护性。
