@Override public void onError(AsyncEvent event) throws IOException { // Broken pipe may appear here asyncCtx.complete(); } // other methods...
The flush() method is the specific trigger here. Flushing forces the buffer to push data immediately over the network rather than waiting for the buffer to fill up. If the server tries to flush data to a socket that the client has just closed, the "Broken Pipe" error is thrown immediately because there is nowhere for that flushed data to go.
// Submit task to executor executor.submit(() -> { try { ServletOutputStream out = asyncCtx.getResponse().getOutputStream(); // write response asyncCtx.complete(); } catch (IOException e) { log.warn("Client disconnected during async processing", e); asyncCtx.complete(); // complete anyway to release container resources } }); If the server tries to flush data to
Proactively checking if the client is still connected is far more efficient. Most servlet containers provide a non-standard but widely supported method: HttpServletRequest.getRemoteAddr() or checking if the response is committed. A more robust approach is to attempt a response.flushBuffer() with a zero-byte write at the beginning of long operations. If an IOException occurs, the thread can exit immediately, freeing resources.
By understanding the error as a symptom of client disconnection rather than a server malfunction, developers can shift from confusion to control. Through graceful exception handling, proactive disconnection checks, asynchronous processing, and careful timeout configuration, the fragile pipe can be managed. Ultimately, building resilience against the broken pipe is not just about fixing an error; it is about respecting the volatile nature of the web and building applications that fail gracefully, efficiently, and silently when their intended recipient is no longer listening. A more robust approach is to attempt a response
When you call ServletOutputStream.flush() , you are forcing the server to send any buffered data immediately. If the connection is gone at that exact moment, the JVM throws this IOException . Common Causes
The error java.io.IOException: Broken pipe occurring during a ServletOutputStream flush is a common but often misunderstood issue in Java web development. In simple terms, it means your server tried to send data to a client (like a web browser), but the client was no longer listening. What is a "Broken Pipe"? Far from being a random glitch
In the realm of Java web development, few errors are as simultaneously common and perplexing as the java.io.IOException: Broken pipe when attempting to flush a ServletOutputStream . This error, often accompanied by the message "failed to flush," acts as a digital canary in the coal mine, signaling a fundamental breakdown in communication between the web server and its client. Far from being a random glitch, a "broken pipe" is a specific, albeit often mishandled, symptom of a client disconnecting prematurely. Understanding its root causes, from user behavior to network instability and concurrency issues, is essential for any developer seeking to build robust and resilient web applications.
Alternatively, if you are using asynchronous servlets (Servlet 3.0 AsyncContext ) and the async thread completes after the client has disconnected, the same exception occurs.