Java多线程异常传递与主线程处理机制

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;

import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;

public class CrossThreadExceptionHandling {

    // 假设这是我们的处理器类，它提交任务到线程池
    static class SomeProcessor {
        ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());

        public ListenableFuture<String> doStringProcessing() {
            // 模拟一个可能抛出异常的工作
            return executor.submit(() -> {
                if (System.currentTimeMillis() % 2 == 0) { // 模拟一半几率抛出异常
                    throw new RuntimeException("Error from worker thread!");
                }
                return "Processed stuff";
            });
        }

        public void shutdown() {
            executor.shutdown();
        }
    }

    public static void main(String[] args) throws Throwable {
        System.out.println("Main thread started.");

        SomeProcessor processor = new SomeProcessor();
        // 用于在主线程和工作线程之间共享异常的载体
        AtomicReference<Throwable> sharedException = new AtomicReference<>();
        final Object exceptionNotifier = new Object(); // 用于同步通知的锁对象

        // 提交任务并添加回调
        ListenableFuture<String> future = processor.doStringProcessing();
        Futures.addCallback(future, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("Worker success: " + result);
            }

            @Override
            public void onFailure(Throwable t) {
                System.err.println("Worker caught exception: " + t.getMessage());
                // 工作线程捕获到异常后，将其存储到共享载体并通知主线程
                synchronized (exceptionNotifier) {
                    sharedException.set(t);
                    exceptionNotifier.notifyAll(); // 通知所有等待的线程，包括主线程
                }
            }
        }, MoreExecutors.directExecutor()); // 使用directExecutor避免回调在另一个线程执行，简化示例

        // 主线程进入一个循环，等待并处理可能来自工作线程的异常
        // 在实际应用中，主线程可能需要执行其他任务，而不是简单地阻塞
        while (true) {
            Throwable t;
            synchronized (exceptionNotifier) {
                t = sharedException.get();
                if (t != null) {
                    System.out.println("Main thread received exception. Throwing it now...");
                    processor.shutdown(); // 关闭线程池
                    throw t; // 主线程自行抛出异常
                }
                try {
                    // 如果没有异常，主线程等待通知
                    // 注意：这里可以设置超时，或者在更复杂的应用中，主线程可以执行其他任务
                    exceptionNotifier.wait(1000); // 等待1秒，防止无限阻塞
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.err.println("Main thread interrupted while waiting.");
                    processor.shutdown();
                    return;
                }
            }
            // 如果未来已经完成但没有异常，可以退出循环
            if (future.isDone() && sharedException.get() == null) {
                System.out.println("Future completed without exception, main thread exiting loop.");
                break;
            }
        }

        processor.shutdown(); // 确保关闭线程池
        System.out.println("Main thread finished.");
    }
}