如何基于SWT实现控制台并解决多线程场景下的线程阻塞与程序崩溃问题？

看起来你遇到的核心问题是多线程高频输出导致UI线程被大量更新请求占满，进而引发程序卡顿甚至崩溃——毕竟SWT的UI控件只能在UI线程操作，当成百上千个下载线程同时调用Console.out时，会把大量更新任务塞进UI线程的消息队列，让它根本处理不过来。咱们一步步来解决：

一、先修复Console类的核心设计问题 #

你的Console类目前有两个关键隐患：

1. 全局设置setForeground，如果多个异步更新任务排队，会导致后续输出的颜色被前面的任务覆盖（比如A线程发了红色错误，B线程发了黑色正常，结果A的任务晚执行，把B的输出也改成红色）
2. 每个输出都触发一次asyncExec，高频调用会把UI线程的消息队列撑爆，直接拖垮UI响应

优化后的Console实现 #

我们可以通过批量缓存输出+独立颜色绑定来解决这些问题：

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Display;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Console {
    private static StyledText console;
    // 用阻塞线程安全队列缓存所有输出任务
    private static final BlockingQueue<OutputTask> outputQueue = new LinkedBlockingQueue<>();
    // 标记批量处理线程是否已启动
    private static boolean processorStarted = false;

    // 封装输出任务：绑定内容与对应颜色
    private static class OutputTask {
        String message;
        RGB color;

        OutputTask(String message, RGB color) {
            this.message = message;
            this.color = color;
        }
    }

    public static void init(StyledText styledText) {
        console = styledText;
        // 启动后台批量处理线程（仅初始化一次）
        if (!processorStarted) {
            processorStarted = true;
            new Thread(Console::processOutputQueue, "Console-Output-Processor").start();
        }
    }

    // 错误输出（红色）
    public static void err(String message) {
        if (console != null && !console.isDisposed()) {
            outputQueue.offer(new OutputTask(message, Display.getDefault().getSystemColor(SWT.COLOR_RED).getRGB()));
        }
    }

    // 正常输出（黑色）
    public static void out(String message) {
        if (console != null && !console.isDisposed()) {
            outputQueue.offer(new OutputTask(message, Display.getDefault().getSystemColor(SWT.COLOR_BLACK).getRGB()));
        }
    }

    // 后台线程批量攒任务，减少UI线程压力
    private static void processOutputQueue() {
        List<OutputTask> batch = new ArrayList<>(100); // 每次攒100条再发给UI线程
        while (processorStarted) {
            try {
                // 先取一条阻塞等待，再尝试批量取剩余任务，最多等100ms凑批量
                batch.add(outputQueue.take());
                outputQueue.drainTo(batch, 99);

                // 把批量任务交给UI线程处理
                if (!batch.isEmpty()) {
                    Display.getDefault().asyncExec(() -> updateConsoleBatch(batch));
                    batch.clear();
                }
            } catch (InterruptedException e) {
                // 线程被中断时退出循环
                Thread.currentThread().interrupt();
                break;
            }
        }
    }

    // UI线程内批量更新控制台，减少重绘次数
    private static void updateConsoleBatch(List<OutputTask> tasks) {
        Display display = Display.getCurrent();
        if (display == null || console == null || console.isDisposed()) {
            return;
        }

        // 开启批量更新模式，避免频繁重绘
        console.setRedraw(false);
        try {
            for (OutputTask task : tasks) {
                int start = console.getText().length();
                console.append(task.message);
                int end = console.getText().length();
                // 用StyleRange单独设置这段文本的颜色，不会影响其他输出
                console.setStyleRange(new StyleRange(start, end - start, new Color(display, task.color), null));
            }
            // 滚动到最后一行，保持最新内容可见
            console.setCaretOffset(console.getText().length());
            console.setTopIndex(console.getLineCount() - 1);
        } finally {
            console.setRedraw(true);
        }
    }

    // 程序退出时清理资源
    public static void shutdown() {
        processorStarted = false;
        outputQueue.clear();
    }
}

这个优化的核心亮点：

1. 用阻塞队列缓存所有输出，后台线程批量处理，把成百上千次UI请求压缩成少数几次
2. 用StyleRange替代全局setForeground，彻底解决颜色串色问题
3. 加入控件isDisposed()检查，避免窗口关闭后还执行无效UI操作

二、从输出源头控制频率 #

除了优化Console，还要从下载线程的输出逻辑上减少高频请求：

• 合并统计输出：不要每个文件都输出结果，而是每隔2-3秒输出一次整体进度（比如“已下载50/200，成功45，失败5”），下载完成后再输出详细结果
• 批量收集结果：如果一定要看单文件结果，可以先把下载状态存到线程安全容器，最后一次性输出，示例如下：

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

// 在线程安全容器中暂存下载结果
private static final ConcurrentHashMap<String, Boolean> downloadResults = new ConcurrentHashMap<>();

public boolean downloadAndSaveImage(ImgData imgData) {
    Path filePath = imgData.getFilePath();
    URL srcUrl = imgData.getSrc();
    boolean success = attemptDownload(filePath, srcUrl);
    // 先存结果，不直接输出
    downloadResults.put(filePath.getFileName().toString(), success);
    return success;
}

// 所有下载完成后批量输出
public void printFinalDownloadResults() {
    StringBuilder sb = new StringBuilder("下载结果汇总：\n");
    for (Map.Entry<String, Boolean> entry : downloadResults.entrySet()) {
        sb.append(String.format("%s is %s%n", entry.getKey(), entry.getValue() ? "Successful" : "Failed"));
    }
    Console.out(sb.toString());
    downloadResults.clear();
}

三、排查其他潜在阻塞点 #

你提到的“线程阻塞甚至崩溃”，还要注意这几个细节：

1. 检查attemptDownload方法有没有设置网络超时，无超时的网络请求会导致下载线程长期阻塞，间接让程序看起来像崩溃
2. 你的CountDownLatch如果等待几千个线程，可能引发内存问题，可以换成CompletableFuture管理下载任务，更灵活且资源占用更低
3. 确保所有UI控件操作（比如按钮状态修改）都在asyncExec中执行，避免跨线程操作SWT控件触发异常

总结 #

优先优化Console类的批量输出逻辑，从根本上减少UI线程的压力；再从输出源头控制频率，避免高频请求；最后检查下载线程的资源管理是否合理。这样应该能彻底解决你的线程阻塞和程序崩溃问题。

备注：内容来源于stack exchange，提问作者user23381600