Understanding the java.net.SocketException Broken Pipe Error

1. Overview

In this tutorial, we’ll take a closer look at the Java “java.net.SocketException: “Broken pipe” error. In the first step, we’ll demonstrate how this exception is reproduced. Our next step will be to understand the leading cause of the exception, and then we’ll see how this can be fixed.

2. Practical Example

Now, let’s see an example that generates the error “java.net.SocketException: “Broken pipe“.

To put it simply, a broken pipe typically happens when one device tries to read or write data from another device that has died or the connection has been broken.

As the connection is closed, a new connection must be established to continue transferring data. Otherwise, the data stops transferring.

2.1. Setup Client and Server

For simulating this locally, we’ll use a Server class working as our web server and a Client class working as our client machine.

Once we close the server socket, the client connected to that still sends the message and receives the error message.

This also happens if the server sends some response to the client, and the client loses connection in the meantime.

As the first step, let’s create a server class called Server listening on port 1234:

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(1234);
            System.out.println("Server listening on port 1234...");

            Socket clientSocket = serverSocket.accept();
            System.out.println("Client connected: " + clientSocket.getInetAddress());
            //Add some delay for reading from client
            Thread.sleep(2000);
            InputStream in = clientSocket.getInputStream();
            System.out.println("Reading from client:" + in.read());
            in.close();
            clientSocket.close();
            serverSocket.close();
        }
        catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Secondly, let’s create a client Client and attach it to the 1234 port socket:

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 1234);
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("HELLO".getBytes());
            System.out.println("Writing to server..");
            //Here we are writing again.
            outputStream.write("HI".getBytes());
            System.out.println("Writing to server again..");
            System.out.println("Closing client.");
            outputStream.close();
            socket.close();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Here, we’re sending some messages to the server, and the server is reading and printing that. Once we run the server and start the client, we see no error as data is sent before the server closes the socket:

// Server console
Server listening on port 12345...
Client connected: /127.0.0.1
Reading from client:66

// Client console
writing to server..
writing to server again..
Closing client.

2.2. Reproduce the Broken Pipe Error

In order to get the error, let’s delay sending the next message from the Client until the server has closed the connection:

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 1234);
            OutputStream outputStream = socket.getOutputStream();
            outputStream.write("HELLO".getBytes());
            System.out.println("Writing to server..");
            // Simulating a delay after writing to the socket
            Thread.sleep(3000);
            outputStream.write("HI".getBytes());
            System.out.println("Writing to server again..");
            System.out.println("Closing client.");
            outputStream.close();
            socket.close();
        }
        catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Let’s run it again and see that the server socket is closed, and if the client sends the message, it’s returned with a broken pipe error:

// Server console
Server listening on port 12345...
Client connected: /127.0.0.1
Reading from client:66

// Client console
Writing to server..
java.net.SocketException: Broken pipe (Write failed)
	at java.net.SocketOutputStream.socketWrite0(Native Method)
	at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:111)
	at java.net.SocketOutputStream.write(SocketOutputStream.java:143)
	at com.baeldung.socketexception.brokenpipe.Client.main(Client.java:18)

3. Cause

An example of this error is when a client program, such as a browser window that loads a website, crashes, or terminates before it has fully read data from the server. If the connection is closed, any attempt by the client to write data to the server after that results in a ‘Broken pipe’ error.

When it comes to network sockets, this can happen if the network cable is unplugged or the process on the other end doesn’t work. In this case, the connection may have been terminated unexpectedly, or the network may be experiencing issues.

As far as Java is concerned, there is no BrokenPipeException specifically. This error is usually bundled with others, such as SocketException and IOException.

There can be several reasons for a client to lose connection, including closing the browser before the server responds, overloaded servers, or long response times.

4. Solution

There’s no guarantee that the client/server will always wait for graceful connection closing. However, it’s still possible to deal with a broken pipe error in an efficient way.

It’s always advisable to ensure that the client and server handle socket connections appropriately and gracefully close streams and sockets in order to manage Java’s “Broken pipe” error.

We must also manage the timeout effectively and respond quickly.

Again, there isn’t a universal fix. We need to identify the underlying issue and address it appropriately.

5. Conclusion

In this article, we learned about Java’s “java.net.SocketException Broken pipe” error. Then, we discussed how to produce the error and understood the cause of the exception. Lastly, we looked at possible ways to handle the error.