如何在Thread的run方法中合理处理已检查异常IOException？

现有三个核心类：

1. Downloading类：继承自Thread，run方法实现下载逻辑，内部捕获了IOException但未做处理；
2. DownloadingManager类：管理下载线程列表，提供start方法启动下载任务；
3. CommandAnalyzer类：解析命令，调用DownloadingManager启动下载，并通过try-catch尝试捕获异常。

需求是让Downloading的run方法中发生的IOException能被上层（CommandAnalyzer）感知并处理，但受限于Thread的run方法无法抛出检查型异常，尝试过Thread.UncaughtExceptionHandler（无法处理检查型异常）、给Downloading加异常字段（违反SOLID原则）均不可行，需要找到合规的解决方案。

核心代码片段 #

Downloading类的run方法 #

@Override
public void run() {
    int attempt = 1;
    String currentTry = destination + "/" + fileName;
    while(Files.exists(Paths.get(currentTry))){
          currentTry = String.format(destination + "/(%s)" + fileName, attempt);
          attempt++;
    }
    fileName = currentTry;
    try {
         Files.createFile(Paths.get(currentTry));
         OutputStream os = new BufferedOutputStream(Files.newOutputStream(Paths.get(currentTry)), contentLength);
         InputStream is = source.openConnection().getInputStream();
         int info;
         while ((info = is.read()) != -1) {
                 os.write(info);
                 downloadedBytes++;
                }
         os.flush();
         os.close();
         is.close();
    } catch (IOException ex){
          // 目前无处理，无法传递到上层
    }
}

DownloadingManager类 #

private List<iDownloading> threads = new ArrayList<>();

@Override
public void start(iDownloading downloading) throws IOException {
    threads.add(downloading);
    downloading.start();
}

CommandAnalyzer类 #

public Object getResult(Object command) {
    if (command.equals("-status")){
        return downloadingsManager.getInfo();
    }
    String[] commandParts = ((String)command).split(",");

    if (commandParts.length == 2){
        Path destPath = Paths.get(commandParts[1]).toAbsolutePath().normalize();
        if (!Files.exists(destPath) || !Files.isDirectory(destPath)){
            return "can't perform command as second argument is not real directory";
        }
        try {
            downloadingsManager.start(new DownloadingWithProgressBar(commandParts[0], commandParts[1]));
            return "downloading started successfully";
        } catch (IOException ex){
            return "something went wrong. try again";
        }
    } else {
        return "unknown command";
    }
}

方案1：基于事件监听的异常传递（符合SOLID） #

通过定义抽象的异常监听接口，让Downloading类依赖抽象而非具体上层类，实现异常的异步传递。

1. 定义异常监听接口

public interface DownloadFailureListener {
    void onFailure(IOException exception);
}

2. 改造Downloading类，支持注册监听器

public class Downloading extends Thread {
    private final List<DownloadFailureListener> failureListeners = Collections.synchronizedList(new ArrayList<>());

    // 添加监听器注册方法
    public void addFailureListener(DownloadFailureListener listener) {
        failureListeners.add(listener);
    }

    @Override
    public void run() {
        // 原有下载逻辑...
        try {
             // 下载代码
        } catch (IOException ex) {
             // 通知所有注册的监听器
             for (DownloadFailureListener listener : failureListeners) {
                 listener.onFailure(ex);
             }
        }
    }
}

3. 在CommandAnalyzer中注册监听器处理异常

public Object getResult(Object command) {
    // 原有命令解析逻辑...
    try {
        DownloadingWithProgressBar task = new DownloadingWithProgressBar(commandParts[0], commandParts[1]);
        // 注册异常监听器，处理下载过程中的异常
        task.addFailureListener(ex -> {
            // 可在此记录日志、更新下载状态，或通过DownloadingManager同步状态供-status命令查询
            System.err.println("Download failed: " + ex.getMessage());
        });
        downloadingsManager.start(task);
        return "downloading started successfully";
    } catch (IOException ex){
        return "something went wrong. try again";
    }
}

优势：严格遵循依赖倒置原则（依赖抽象接口而非具体类），对扩展开放（新增异常处理逻辑只需实现新的Listener），对修改关闭（无需改动Downloading核心逻辑）。

方案2：使用CompletableFuture包装异步任务 #

利用Java 8+的CompletableFuture处理异步任务的异常传递，替代原生Thread，更灵活地处理异步结果与异常。

1. 改造Downloading类，提取下载逻辑为独立方法

public class Downloading {
    // 原有成员变量...

    // 提取下载逻辑，抛出IOException
    public void performDownload() throws IOException {
        int attempt = 1;
        String currentTry = destination + "/" + fileName;
        while(Files.exists(Paths.get(currentTry))){
              currentTry = String.format(destination + "/(%s)" + fileName, attempt);
              attempt++;
        }
        fileName = currentTry;
        // 使用try-with-resources自动关闭流
        try (OutputStream os = new BufferedOutputStream(Files.newOutputStream(Paths.get(currentTry)), contentLength);
             InputStream is = source.openConnection().getInputStream()) {
             int info;
             while ((info = is.read()) != -1) {
                     os.write(info);
                     downloadedBytes++;
                    }
             os.flush();
        }
    }
}

2. 修改DownloadingManager，使用CompletableFuture管理任务

public class DownloadingManager {
    private final List<CompletableFuture<Void>> tasks = new ArrayList<>();

    public CompletableFuture<Void> start(Downloading downloading) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                downloading.performDownload();
            } catch (IOException e) {
                // 将检查型异常包装为CompletionException（非检查型）
                throw new CompletionException(e);
            }
        });
        tasks.add(future);
        return future;
    }
}

3. 在CommandAnalyzer中处理异步异常

public Object getResult(Object command) {
    // 原有命令解析逻辑...
    try {
        DownloadingWithProgressBar task = new DownloadingWithProgressBar(commandParts[0], commandParts[1]);
        CompletableFuture<Void> future = downloadingsManager.start(task);
        // 处理异步异常
        future.exceptionally(ex -> {
            if (ex.getCause() instanceof IOException) {
                IOException downloadEx = (IOException) ex.getCause();
                // 处理异常逻辑
                System.err.println("Download failed: " + downloadEx.getMessage());
            }
            return null;
        });
        return "downloading started successfully";
    } catch (IOException ex){
        return "something went wrong. try again";
    }
}

优势：利用Java标准库的异步工具，代码更简洁，支持链式调用处理异常，同时保持Downloading类的单一职责（仅负责下载逻辑）。

• Thread的run方法是void返回类型，且不允许抛出检查型异常，因此IOException必须在run方法内部捕获，无法直接向上抛出；
• Thread.UncaughtExceptionHandler仅能处理未捕获的运行时异常或Error，检查型异常必须被显式捕获，因此无法通过该机制传递IOException；
• 给Downloading类添加异常字段并在接口中增加获取方法，会违反依赖倒置原则（上层需要依赖Downloading的具体实现而非抽象接口），同时破坏类的封装性。

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