How to Handle Java SocketException

1. Introduction

In this tutorial, we'll learn the causes of SocketException with an example. We’ll also discuss how to handle the exception.

2. Causes of SocketException

The most common cause of SocketException is writing or reading data to or from a closed socket connection. Another cause of it is closing the connection before reading all data in the socket buffer.

Let's take a closer look at some common underlying reasons.

2.1. Slow Network

A poor network connection might be the underlying problem. Setting a higher socket connection timeout can decrease the rate of SocketException for slow connections:

socket.setSoTimeout(30000); // timeout set to 30,000 ms

2.2. Firewall Intervention

A network firewall can close socket connections. If we have access to the firewall, we can turn it off and see if it solves the problem.

Otherwise, we can use a network monitoring tool such as Wireshark to check firewall activities.

2.3. Long Idle Connection

Idle connections might get forgotten by the other end (to save resources). If we have to use a connection for a long time, we can send heartbeat messages to prevent idle state.

2.4. Application Error

Last but not least, SocketException can occur because of mistakes or bugs in our code.

To demonstrate this, let's start a server on port 6699:

SocketServer server = new SocketServer();
server.start(6699);

When the server is started, we'll wait for a message from the client:

serverSocket = new ServerSocket(port);
clientSocket = serverSocket.accept();
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String msg = in.readLine();

Once we get it, we'll respond and close the connection:

out.println("hi");
in.close();
out.close();
clientSocket.close();
serverSocket.close();

So, let's say a client connects to our server and sends “hi”:

SocketClient client = new SocketClient();
client.startConnection("127.0.0.1", 6699);
client.sendMessage("hi");

So far, so good.

But, if the client sends another message:

client.sendMessage("hi again");

Since the client sends “hi again” to the server after the connection is aborted, a SocketException occurs.

3. Handling of a SocketException

Handling SocketException is pretty easy and straightforward. Similar to any other checked exception, we must either throw it or surround it with a try-catch block.

Let's handle the exception in our example:

try {
    client.sendMessage("hi");
    client.sendMessage("hi again");
} catch (SocketException e) {
    client.stopConnection();
}

Here, we've closed the client connection after the exception occurred. Retrying won't work, because the connection is already closed. We should start a new connection instead:

client.startConnection("127.0.0.1", 6699);
client.sendMessage("hi again");

4. Conclusion

In this article, we learned what causes SocketException and how to handle it.

As always, the code is available over on Github.