Ошибка java socket exception - Исправление ошибок и поиск оптимальных решений проблем

The SocketException is an exception in Java that is thrown to indicate that an error was encountered while creating or accessing a Socket.

Since the SocketException is a checked exception, it either needs to be thrown or surrounded by a try-catch block in code.

What Causes SocketException

SocketException is a subclass of IOException and is the most general exception that indicates a problem when trying to open or access a socket. Some common causes for the SocketException are:

Closed socket connection — The most common cause of SocketException is reading or writing from or to a closed socket connection. It can also occur when the connection is closed before all the data is read in the socket buffer.
Slow network — A poor network connection might also cause a SocketException. Setting a higher connection timeout can decrease the rate of SocketException for slow connections.
Network firewall — A network firewall can close socket connections. A network monitoring tool like Wireshark can be used to check firewall activities.
Idle connection — Long idle connections might also cause a SocketException. If a connection needs to be used for a long time, heartbeat messages can be sent to prevent the idle state.
Errors in code — A SocketException can also occur because of issues or bugs in code. For example, if a client sends a message to the server after the socket connection is closed.

SocketException Example

The following is an example of a SocketException thrown when trying to write to a closed socket connection. Two classes, MyServer and MyClient are created to illustrate this.

MyServer.java:

public class MyServer {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Server()).start();
    }

    static class Server implements Runnable {
        @Override
        public void run() {
            ServerSocket serverSocket = null;

            try {
                serverSocket = new ServerSocket(4444);

                while (true) {
                    try {
                        Socket clientSocket = serverSocket.accept();

                        BufferedReader inputReader = new BufferedReader(
                                new InputStreamReader(clientSocket.getInputStream()));
                        System.out.println("Message from client: " + inputReader.readLine());
                    } catch (SocketTimeoutException ste) {
                        ste.printStackTrace();
                    }
                }
            } catch (IOException ioe) {
                ioe.printStackTrace();
            } finally {
                try {
                    if (serverSocket != null) {
                        serverSocket.close();
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }
    }
}

Executing MyServer.main() starts a new Server thread, which creates a ServerSocket object on port 4444. The server socket accepts incoming connections on that port, creates an InputStreamReader object from the input stream coming from the client socket, then reads and prints the message sent by the client. A continuous while loop is used to await the connection and print the message received from the client.

MyClient.java:

public class MyClient {
    public static void main(String[] args) {
        new Thread(new Client()).start();
    }

    static class Client implements Runnable {
        @Override
        public void run() {
            Socket socket = null;

            try {
                socket = new Socket("localhost", 4444);

                PrintWriter outWriter = new PrintWriter(socket.getOutputStream(), true);
                outWriter.println("Hello");

                outWriter.close();
                socket.close();

                outWriter = new PrintWriter(socket.getOutputStream(), true);
                outWriter.println("Hello again");
            } catch (UnknownHostException uhe) {
                uhe.printStackTrace();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            } finally {
                try {
                    if (socket != null) {
                        socket.close();
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }
    }
}

The MyClient.main() method above starts a Client thread, which creates a Socket instance and connects to the server host (localhost) and port (4444) defined earlier. A PrintWriter object is then created using the socket output stream to send a message to the server. This works fine and the message is printed by the server:

Message from client: Hello

The socket is then closed and another PrintWriter object is attempted to be created using the closed socket’s output stream. However, since the socket is closed, writing to it is not possible. Therefore, a SocketException is thrown:

java.net.SocketException: Socket is closed
    at java.net.Socket.getOutputStream(Socket.java:943)
    at MyClient$Client.run(MyClient.java:26)
    at java.lang.Thread.run(Thread.java:748)

How to Handle SocketException

Since SocketException is a checked exception, it can be handled by surrounding it with a try-catch block. The MyClient class in the earlier example can be updated to handle the exception:

public class MyClient {
    public static void main(String[] args) {
        new Thread(new Client()).start();
    }

    static class Client implements Runnable {
        @Override
        public void run() {
            Socket socket = null;

            try {
                socket = new Socket("localhost", 4444);

                PrintWriter outWriter = new PrintWriter(socket.getOutputStream(), true);
                outWriter.println("Hello");

                outWriter.close();
                socket.close();

                try {
                    outWriter = new PrintWriter(socket.getOutputStream(), true);
                } catch (SocketException se) {
                    if (socket.isClosed()) {
                        socket = new Socket("localhost", 4444);
                        outWriter = new PrintWriter(socket.getOutputStream(), true);
                    }
                }

                outWriter.println("Hello again");
            } catch (UnknownHostException uhe) {
                uhe.printStackTrace();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            } finally {
                try {
                    if (socket != null) {
                        socket.close();
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }
    }
}

In the above example, the code that can throw the SocketException is surrounded in a try-catch block. In case a SocketException occurs when attempting to write to the socket, it is caught in the catch block and the socket instance is created and connected again to the server host and port. The PrintWriter object is also created again using the new socket output stream to send the second message to the server. This works successfully and both messages are now printed by the server:

Message from client: Hello
Message from client: Hello again

Track, Analyze and Manage Errors With Rollbar

Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you to proceed with more confidence. Rollbar automates error monitoring and triaging, making fixing Java errors easier than ever. Sign Up Today!

Источник

SocketException is a subclass of IOException so it’s a checked exception. It is the most general exception that signals a problem when trying to open or access a socket. The full exception hierarchy of this error is:

java.lang.Object
     java.lang.Throwable
         java.lang.Exception
             java.io.IOException
                 java.net.SocketException

As you might already know, it’s strongly advised to use the most specific socket exception class that designates the problem more accurately. It is also worth noting that SocketException, usually comes with an error message that is very informative about the situation that caused the exception.

Implemented Interfaces: Serializable
Direct Known Subclasses: BindException, ConnectException, NoRouteToHostException, PortUnreachableException

What is socket programming?

It is a programming concept that makes use of sockets to establish connections and enables multiple programs to interact with each other using a network. Sockets provide an interface to establish communication using the network protocol stack and enable programs to share messages over the network. Sockets are endpoints in network communications. A socket server is usually a multi-threaded server that can accept socket connection requests. A socket client is a program/process that initiates a socket communication request.

java.net.SocketException: Connection reset

This SocketException occurs on the server-side when the client closed the socket connection before the response could be returned over the socket. For example, by quitting the browser before the response was retrieved. Connection reset simply means that a TCP RST was received. TCP RST packet is that the remote side telling you the connection on which the previous TCP packet is sent is not recognized, maybe the connection has closed, maybe the port is not open, and something like these. A reset packet is simply one with no payload and with the RST bit set in the TCP header flags.

Now as of implementation it is clear that we need two programs one handling the client and the other handling the server. They are as follows:

Example 1: Server-side

Java

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.SocketTimeoutException;

public class SimpleServerApp {

public static void main(String[] args)

throws InterruptedException

{

new Thread(new SimpleServer()).start();

}

static class SimpleServer implements Runnable {

@Override public void run()

{

ServerSocket serverSocket = null;

try {

serverSocket = new ServerSocket(3333);

serverSocket.setSoTimeout(0);

while (true) {

try {

Socket clientSocket

= serverSocket.accept();

BufferedReader inputReader

= new BufferedReader(

new InputStreamReader(

clientSocket

.getInputStream()));

System.out.println(

"Client said :"

+ inputReader.readLine());

}

catch (SocketTimeoutException e) {

e.printStackTrace();

}

catch (IOException e1) {

e1.printStackTrace();

}

finally {

try {

if (serverSocket != null) {

serverSocket.close();

}

catch (IOException e) {

e.printStackTrace();

}

Example 2: Client-side

Java

import java.io.IOException;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.SocketException;

import java.net.UnknownHostException;

public class SimpleClientApp {

public static void main(String[] args)

{

new Thread(new SimpleClient()).start();

}

static class SimpleClient implements Runnable {

@Override public void run()

{

Socket socket = null;

try {

socket = new Socket("localhost", 3333);

PrintWriter outWriter = new PrintWriter(

socket.getOutputStream(), true);

System.out.println("Wait");

Thread.sleep(15000);

outWriter.println("Hello Mr. Server!");

}

catch (SocketException e) {

e.printStackTrace();

}

catch (InterruptedException e) {

e.printStackTrace();

}

catch (UnknownHostException e) {

e.printStackTrace();

}

catch (IOException e) {

e.printStackTrace();

}

finally {

try {

if (socket != null)

socket.close();

}

catch (IOException e) {

e.printStackTrace();

}

Output:

java.net.SocketException: Connection reset

at java.net.SocketInputStream.read(SocketInputStream.java:196)

at java.net.SocketInputStream.read(SocketInputStream.java:122)

at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:283)

at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:325)

at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:177)

at java.io.InputStreamReader.read(InputStreamReader.java:184)

at java.io.BufferedReader.fill(BufferedReader.java:154)

at java.io.BufferedReader.readLine(BufferedReader.java:317)

at java.io.BufferedReader.readLine(BufferedReader.java:382)

at com.javacodegeeks.core.lang.NumberFormatExceptionExample.SimpleServerApp$SimpleServer.run(SimpleServerApp.java:36)

at java.lang.Thread.run(Thread.java:744)

Now in order to get rid off of the java.net.SocketException to get proper output then it can be perceived via as if you are a client and getting this error while connecting to the server-side application then append the following changes as follows:

First, check if the Server is running by doing telnet on the host port on which the server runs.
Check if the server was restarted
Check if the server failed over to a different host
log the error
Report the problem to the server team

Note: In most cases, you will find that either server is not running or restarted manually or automatically.

Источник

You should inspect full trace very carefully,

I’ve a server socket application and fixed a java.net.SocketException: Connection reset case.

In my case it happens while reading from a clientSocket Socket object which is closed its connection because of some reason. (Network lost,firewall or application crash or intended close)

Actually I was re-establishing connection when I got an error while reading from this Socket object.

Socket clientSocket = ServerSocket.accept();
is = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
int readed = is.read(); // WHERE ERROR STARTS !!!

The interesting thing is for my JAVA Socket if a client connects to my ServerSocket and close its connection without sending anything is.read() is being called repeatedly.It seems because of being in an infinite while loop for reading from this socket you try to read from a closed connection.
If you use something like below for read operation;

while(true)
{
  Receive();
}

Then you get a stackTrace something like below on and on

java.net.SocketException: Socket is closed
    at java.net.ServerSocket.accept(ServerSocket.java:494)

What I did is just closing ServerSocket and renewing my connection and waiting for further incoming client connections

String Receive() throws Exception
{
try {                   
            int readed = is.read();
           ....
}catch(Exception e)
{
        tryReConnect();
        logit(); //etc
}


//...
}

This reestablises my connection for unknown client socket losts

private void tryReConnect()
        {
            try
            {
                ServerSocket.close();
                //empty my old lost connection and let it get by garbage col. immediately 
                clientSocket=null;
                System.gc();
                //Wait a new client Socket connection and address this to my local variable
                clientSocket= ServerSocket.accept(); // Waiting for another Connection
                System.out.println("Connection established...");
            }catch (Exception e) {
                String message="ReConnect not successful "+e.getMessage();
                logit();//etc...
            }
        }

I couldn’t find another way because as you see from below image you can’t understand whether connection is lost or not without a try and catch ,because everything seems right . I got this snapshot while I was getting Connection reset continuously.

Источник

In this blog, I plan to talk about some common exceptions and errors that arise while using sockets. Quite often, these socket issues arise out of application bugs, system settings, or system load. It might be an unnecessary delay to go to product teams, only to discover that the issue can be resolved by tuning/configuring your local settings. Understanding these messages will not only help resolve the issues but also make a conscious effort in avoiding these scenarios while developing applications.

I have tried to make the blog as much platform-independent as possible :). You may want to search the web if you wish to know the specifics. Though, if you are not familiar with Socket programming in Java then I also suggest you check the Java: Socket Programming Simplified, a free course on Udemy.

How to fix java.net.SocketException: Broken pipe, Connection reset, and Too many open files in Java?

Now, here are some common Socket related errors in Java, their explanation, and thoughts on how to solve them.

1. java.net.SocketException: No buffer space available (maximum connections reached?)

This exception is usually observed When connections are being made at a rapid rate. This exception can arise due to one of the following conditions

a. When the number of available ephemeral network ports available for the application are nil.
b. When the system does not have enough main memory to support new connections. (Whenever a socket is created, a part of the memory is allocated for its READ/SEND buffers.. from non-paged kernel memory.)

Solution: In Windows, the number of ephemeral network ports can be increased as directed here to resolve the problem arising out of case ‘a’.

The only available solution for case ‘b’ is to make sure that the network connections are closed properly by the applications. And make sure the rate at which the connections are created does not throttle the kernel memory.

Currently, there are no formally documented approaches available to increase non-paged kernel memory. You can also see these free Java Programming courses to learn more about Socket programming in Java.

2. java.net.SocketException: Broken pipe (UNIX)

A broken pipe error is seen when the remote end of the connection is closed gracefully.
Solution: This exception usually arises when the socket operations performed on either end are not synced.

3. java.net.SocketException: Connection reset [Solution]

This exception appears when the remote connection is unexpectedly and forcefully closed due to various reasons like application crashes, system reboot, the hard close of the remote host. Kernel from the remote system sends out packets with the RST bit to the local system.

The local socket on performing any SEND (could be a Keep-alive packet) or RECEIVE operations subsequently fail with this error. Certain combinations of linger settings can also result in packets with an RST bit set.

4. java.net.SocketException: Too many open files Solution

An attempt was made to open more than the maximum number of file descriptors allowed in this process. These file descriptors include various other entities along with sockets. This is implementation-dependent and could be either globally, per process, or per thread. On Linux, this is designated by the number {OPEN_MAX}.

Solution: Monitor the application and keep a watch on this. These values may be configurable on certain implementations. On Linux, ulimit can be used.

5. java.net.BindException: Address already in use: JVM_Bind/java.net.BindException: Address already in use: NET_Bind

In the case, where the exception arises while doing a socket bind. The reason is that the application is trying to bind a socket to a port/IP/protocol combination that is already in use.

Solution: Avoid this. netstat log will be of help in this case to confirm. If you want to learn more about Socket Programming in Java, I suggest you check the Java: Socket Programming Simplified, a free course on Udemy.

6. java.net.BindException: Address already in use: connect

In the case, where the exception arises while doing a socket connection. There are several explanations for this some of the complex, depending on the implementation. Nonetheless, the problem can best be summarized that no local port numbers are available to the client.

This could be because there are a lot of active connections in the local system(also involves sockets in a reuse connections phenomenon).

Or a lot of ports are in TIME_WAIT state(the period between closing a connection and releasing the resources).

Solution: Increase the number of available ports. But if the problem is that there are not many concurrent active connections but in the TIME_WAIT state, then reducing the TIME_WAIT value is a solution. This is platform-dependent. Please consult the OS documents for more information.

7. Hang in Socket Write call

This happens when the sockets write buffers do not contain enough free space to accommodate the send data. This usually means the other side of the connection is not reading the data.

That’s all about the most common Socket errors and exceptions in Java applications. In this article, we have covered 7 most common Socket related errors and exceptions like Broken Pipe, Connection Reset, Too many open files, address already in use for bind and connect, and no buffer space available in Java and how to deal with them.

Источник

Содержание

java.net.SocketException in Java with Examples
How to Handle the Socket Exception in Java
What Causes SocketException
SocketException Example
How to Handle SocketException
Track, Analyze and Manage Errors With Rollbar
Java socket connect exception
Constructor Summary
Method Summary
Methods inherited from class java.lang.Object
Constructor Detail
Socket
Socket
Socket
Socket
Socket
Socket
Socket
Socket
Socket
Method Detail
connect
connect
getInetAddress
getLocalAddress
getPort
getLocalPort
getRemoteSocketAddress
getLocalSocketAddress
getChannel
getInputStream
getOutputStream
setTcpNoDelay
getTcpNoDelay
setSoLinger
getSoLinger
sendUrgentData
setOOBInline
getOOBInline
setSoTimeout
getSoTimeout
setSendBufferSize
getSendBufferSize
setReceiveBufferSize
getReceiveBufferSize
setKeepAlive
getKeepAlive
setTrafficClass
getTrafficClass
setReuseAddress
getReuseAddress
close
shutdownInput
shutdownOutput
toString
isConnected
isBound
isClosed
isInputShutdown
isOutputShutdown
setSocketImplFactory
setPerformancePreferences

java.net.SocketException in Java with Examples

What is socket programming?

java.net.SocketException: Connection reset

Now as of implementation it is clear that we need two programs one handling the client and the other handling the server. They are as follows:

Источник

How to Handle the Socket Exception in Java

The SocketException is an exception in Java that is thrown to indicate that an error was encountered while creating or accessing a Socket.

Since the SocketException is a checked exception, it either needs to be thrown or surrounded by a try-catch block in code.

What Causes SocketException

SocketException is a subclass of IOException and is the most general exception that indicates a problem when trying to open or access a socket. Some common causes for the SocketException are:

Closed socket connection — The most common cause of SocketException is reading or writing from or to a closed socket connection. It can also occur when the connection is closed before all the data is read in the socket buffer.
Slow network — A poor network connection might also cause a SocketException . Setting a higher connection timeout can decrease the rate of SocketException for slow connections.
Network firewall — A network firewall can close socket connections. A network monitoring tool like Wireshark can be used to check firewall activities.
Idle connection — Long idle connections might also cause a SocketException . If a connection needs to be used for a long time, heartbeat messages can be sent to prevent the idle state.
Errors in code — A SocketException can also occur because of issues or bugs in code. For example, if a client sends a message to the server after the socket connection is closed.

SocketException Example

The following is an example of a SocketException thrown when trying to write to a closed socket connection. Two classes, MyServer and MyClient are created to illustrate this.

Executing MyServer.main() starts a new Server thread, which creates a ServerSocket object on port 4444. The server socket accepts incoming connections on that port, creates an InputStreamReader object from the input stream coming from the client socket, then reads and prints the message sent by the client. A continuous while loop is used to await the connection and print the message received from the client.

The MyClient.main() method above starts a Client thread, which creates a Socket instance and connects to the server host (localhost) and port (4444) defined earlier. A PrintWriter object is then created using the socket output stream to send a message to the server. This works fine and the message is printed by the server:

The socket is then closed and another PrintWriter object is attempted to be created using the closed socket’s output stream. However, since the socket is closed, writing to it is not possible. Therefore, a SocketException is thrown:

How to Handle SocketException

Since SocketException is a checked exception, it can be handled by surrounding it with a try-catch block. The MyClient class in the earlier example can be updated to handle the exception:

In the above example, the code that can throw the SocketException is surrounded in a try-catch block. In case a SocketException occurs when attempting to write to the socket, it is caught in the catch block and the socket instance is created and connected again to the server host and port. The PrintWriter object is also created again using the new socket output stream to send the second message to the server. This works successfully and both messages are now printed by the server:

Track, Analyze and Manage Errors With Rollbar

Источник

Java socket connect exception

The actual work of the socket is performed by an instance of the SocketImpl class. An application, by changing the socket factory that creates the socket implementation, can configure itself to create sockets appropriate to the local firewall.

Constructor Summary

Constructors

Modifier	Constructor and Description
Socket ()

Socket (InetAddress address, int port, InetAddress localAddr, int localPort) Socket (String host, int port, InetAddress localAddr, int localPort)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods

Modifier and Type	Method and Description
void	bind (SocketAddress bindpoint)

void setPerformancePreferences (int connectionTime, int latency, int bandwidth)

Methods inherited from class java.lang.Object

Constructor Detail

Socket

If there is a security manager, its checkConnect method is called with the proxy host address and port number as its arguments. This could result in a SecurityException.

Examples:

Socket s = new Socket(Proxy.NO_PROXY); will create a plain socket ignoring any other proxy configuration.
Socket s = new Socket(new Proxy(Proxy.Type.SOCKS, new InetSocketAddress(«socks.mydom.com», 1080))); will create a socket connecting through the specified SOCKS proxy server.

Socket

If the specified host is null it is the equivalent of specifying the address as InetAddress.getByName (null) . In other words, it is equivalent to specifying an address of the loopback interface.

If the application has specified a server socket factory, that factory’s createSocketImpl method is called to create the actual socket implementation. Otherwise a «plain» socket is created.