本文深入探讨了在java中实现不同运行类之间变量共享和进度更新的多种策略。针对文件复制等耗时操作的进度显示需求，文章介绍了基于回调的观察者模式、基于拉取的迭代器模式以及多线程环境下安全共享变量的方法。通过具体代码示例，详细阐述了如何设计类间通信机制，确保数据一致性和系统可维护性，并提供了在并发编程中处理共享状态的最佳实践。
在Java应用程序开发中，尤其是在处理如文件复制、数据处理或网络传输等耗时操作时，一个常见的需求是在一个类中执行任务，并在另一个类（例如用户界面类）中实时显示任务的进度。直接通过静态变量进行简单的读写操作，虽然在某些简单场景下可行，但在多线程环境或需要更灵活的通知机制时，往往会导致数据不一致、难以维护甚至出现竞态条件等问题。本教程将介绍几种更健壮、更符合面向对象设计原则的解决方案。
这种方法的核心思想是让执行任务的类（Subject，例如文件复制类）持有进度显示类（Observer）的实例。当任务执行过程中有新的进度时，Subject会主动调用Observer类中的特定方法来更新进度。这是一种经典的观察者模式应用，实现了任务执行者与进度显示者之间的松耦合。
假设我们有一个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();
}
}与观察者模式相反，这种方法让进度显示者（Observer）主动地从任务执行者（Subject）那里“拉取”进度信息。进度显示者通过循环不断查询任务执行者的状态，直到任务完成。
立即学习“Java免费学习笔记（深入）”；
// 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();
}
}在实际应用中，耗时操作通常会在一个独立的后台线程中执行，以避免阻塞用户界面。此时，安全地共享变量并更新进度变得尤为重要，需要考虑线程安全和内存可见性问题。
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("所有任务完成。");
}
}选择哪种方法取决于具体的应用场景和对并发的需求：
无论选择哪种方法，良好的代码设计都应遵循职责分离原则，让任务执行者专注于任务本身，而进度显示者专注于显示。通过接口或抽象类来定义通信契约，可以进一步提高代码的灵活性和可维护性。
以上就是Java中跨类变量共享与进度更新的策略的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
375
收藏
