Java如何捕获子线程抛出的异常并在父线程重新抛出？

Great question! The issue you're hitting is a classic one with cross-thread exception handling: since threads execute independently, the RuntimeException you throw from your child thread won't propagate up to the parent thread that called getInputStream(). Let's break down why this happens and how to fix it so you can rethrow the original IOException in the parent thread context.

Why Your Current Approach Fails #

When you start a new thread, it gets its own execution stack. Any uncaught exceptions in that thread (even wrapped RuntimeExceptions) will be handled by the thread's default exception handler (usually printing to the console) instead of bubbling up to the parent thread. That's why your parent thread can't catch it—there's no direct link between the two threads' exception flows.

Solution 1: Propagate Exception When Reading the Stream (Non-Blocking) #

The most idiomatic approach here is to store the exception from the child thread in a thread-safe container, then check for that exception whenever the parent thread tries to read from the InputStream. This way, you don't block the getInputStream() method from returning immediately, and the exception is thrown at the point where it matters most—when you try to use the stream.

Here's how to modify your code:

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.concurrent.atomic.AtomicReference;

public class StreamConverter {

    public InputStream getInputStream() throws IOException {
        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream(in);
        AtomicReference<IOException> exceptionHolder = new AtomicReference<>();

        Thread t = new Thread(() -> {
            try {
                save(out);
            } catch (IOException e) {
                exceptionHolder.set(e);
            } finally {
                // Always close the output stream to avoid blocking the parent thread indefinitely
                try {
                    out.close();
                } catch (IOException closeEx) {
                    // Combine exceptions if both save and close fail
                    if (exceptionHolder.get() != null) {
                        exceptionHolder.set(new IOException("Failed to save and close stream", closeEx));
                    } else {
                        exceptionHolder.set(closeEx);
                    }
                }
            }
        });
        t.start();

        // Wrap the PipedInputStream to check for stored exceptions on every read
        return new FilterInputStream(in) {
            @Override
            public int read() throws IOException {
                checkForException();
                return super.read();
            }

            @Override
            public int read(byte[] b) throws IOException {
                checkForException();
                return super.read(b);
            }

            @Override
            public int read(byte[] b, int off, int len) throws IOException {
                checkForException();
                return super.read(b, off, len);
            }

            private void checkForException() throws IOException {
                IOException storedException = exceptionHolder.get();
                if (storedException != null) {
                    throw storedException;
                }
            }
        };
    }

    private void save(OutputStream out) throws IOException {
        // Your existing save logic here
    }
}

How This Works:

• We use AtomicReference<IOException> to safely share the exception between threads (it's thread-safe, so we avoid race conditions).
• The child thread catches IOException, stores it in the holder, and ensures the PipedOutputStream is closed (this prevents the parent thread from hanging when reading).
• We wrap the PipedInputStream with a FilterInputStream that checks for the stored exception every time a read operation is called. If an exception exists, it's rethrown in the parent thread's context.

Solution 2: Block Until Child Thread Finishes (Synchronous) #

If you don't mind blocking the getInputStream() method until the save() operation completes (e.g., save() is fast), you can wait for the child thread to finish and then check for exceptions immediately:

public InputStream getInputStream() throws IOException, InterruptedException {
    PipedInputStream in = new PipedInputStream();
    PipedOutputStream out = new PipedOutputStream(in);
    AtomicReference<IOException> exceptionHolder = new AtomicReference<>();

    Thread t = new Thread(() -> {
        try {
            save(out);
        } catch (IOException e) {
            exceptionHolder.set(e);
        } finally {
            try {
                out.close();
            } catch (IOException closeEx) {
                if (exceptionHolder.get() == null) {
                    exceptionHolder.set(closeEx);
                }
            }
        }
    });
    t.start();

    // Wait for the child thread to finish its work
    t.join();

    // Check if an exception occurred and rethrow it
    IOException storedException = exceptionHolder.get();
    if (storedException != null) {
        throw storedException;
    }

    return in;
}

Caveat:

This will block the parent thread until save() completes. If save() is a long-running operation, this could hurt performance or cause UI freezes if you're in a desktop application.

Key Takeaways #

• Threads have independent execution stacks, so exceptions in child threads don't automatically propagate to parent threads.
• Use a thread-safe container like AtomicReference to pass exceptions between threads safely.
• For most stream use cases, wrapping the InputStream to check for exceptions on read is the best approach—it keeps the flow non-blocking and throws the exception when the stream is actually used.

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