Socket笔记之Read timed out深入分析

最新推荐文章于 2024-04-26 17:36:43 发布
最新推荐文章于 2024-04-26 17:36:43 发布
阅读量10w+ 收藏 47
点赞数 4
分类专栏： # Socket编程 文章标签： ReadTimedout Read timed out timed out socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usagoole/article/details/82586369
版权

文章目录

ReadTimedOut深入分析

  1. Read timed out就是已经连接成功，但是服务器没有及时返回数据，导致读超时。

  2. java程序模拟Read timed out

    服务端
public class SimpleServer {
    public static void main(String[] args) throws IOException, InterruptedException {
        ServerSocket serverSocket = new ServerSocket(8888,200);
        Thread.sleep(6666666);
    }
}

//客户端程序
@Test
public void testReadTimeOut() {
    Socket socket = new Socket();
    long startTime = 0;
    try {
        socket.connect(new InetSocketAddress("127.0.0.1", 8888), 10000);
        System.out.println("socket连接成功....");
        socket.setSoTimeout(2000);
        startTime = System.currentTimeMillis();
        int read = socket.getInputStream().read();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
    }

}

    执行结果

     	socket连接成功....
	执行时间:2008
	java.net.SocketTimeoutException: Read timed out
		at java.net.SocketInputStream.socketRead0(Native Method)
		at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
		at java.net.SocketInputStream.read(SocketInputStream.java:170)
		at java.net.SocketInputStream.read(SocketInputStream.java:141)
		at java.net.SocketInputStream.read(SocketInputStream.java:223)
		at cn.jannal.net.port.SimpleClient.testReadTimeOut(SimpleClient.java:29)

  3. 模拟超时Read timed out，PSH的意思是控制信息是可以正常传送的，也就是说握手是正常成功的，然后传输数据的时候，我们限制了服务器无法给客户端传送数据内容,与上面java程序模拟的原理类似，都是可以建立连接，但是不返回数据。

     防火墙增加-A OUTPUT -p tcp -m tcp --tcp-flags PSH PSH --sport 8888 -j DROP

  4. 执行流程

    client socket
 socket.setSoTimeout(int timeout)
 	--> socketOptions.setOption(int optID, Object value)
 	 --> AbstractPlainSocketImpl.setOption(int opt, Object val) 
 	  --> PlainSocketImpl.socketSetOption(int cmd, boolean on, Object value)
		--> PlainSocketImpl.c 中的Java_java_net_PlainSocketImpl_socketSetOption

PlainSocketImpl.c

Java_java_net_PlainSocketImpl_socketSetOption

  1. 从以下代码分析可以看出，socket.setSoTimeout(int timeout)选项在Solaris/linux下根本就没有调用C库函数中的setSockOpt(SO_RCVTIMEO)，那java中到底是怎么实现read timed out的呢?

    	/*
	 * Class:     java_net_PlainSocketImpl
	 * Method:    socketSetOption
	 * Signature: (IZLjava/lang/Object;)V
	 */
	JNIEXPORT void JNICALL
	Java_java_net_PlainSocketImpl_socketSetOption(JNIEnv *env, jobject this,
	                                              jint cmd, jboolean on,
	                                              jobject value) {
	    int fd;
	    int level, optname, optlen;
	    union {
	        int i;
	        struct linger ling;
	    } optval;
	
	    /*
	     * Check that socket hasn't been closed
	     */
	    fd = getFD(env, this);
	    if (fd < 0) {
	        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
	                        "Socket closed");
	        return;
	    }
	
	    /*
	     * SO_TIMEOUT is a NOOP on Solaris/Linux
	     * ，在Solaris/linux下根本就没有调用C库函数中的setSockOpt(SO_RCVTIMEO)
	     */
	    if (cmd == java_net_SocketOptions_SO_TIMEOUT) {
	        return;
	    }
	
	    /*
	     * Map the Java level socket option to the platform specific
	     * level and option name.
	     */
	    if (NET_MapSocketOption(cmd, &level, &optname)) {
	        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Invalid option");
	        return;
	    }
	
	    switch (cmd) {
	        case java_net_SocketOptions_SO_SNDBUF :
	        case java_net_SocketOptions_SO_RCVBUF :
	        case java_net_SocketOptions_SO_LINGER :
	        case java_net_SocketOptions_IP_TOS :
	            {
	                jclass cls;
	                jfieldID fid;
	
	                cls = (*env)->FindClass(env, "java/lang/Integer");
	                CHECK_NULL(cls);
	                fid = (*env)->GetFieldID(env, cls, "value", "I");
	                CHECK_NULL(fid);
	
	                if (cmd == java_net_SocketOptions_SO_LINGER) {
	                    if (on) {
	                        optval.ling.l_onoff = 1;
	                        optval.ling.l_linger = (*env)->GetIntField(env, value, fid);
	                    } else {
	                        optval.ling.l_onoff = 0;
	                        optval.ling.l_linger = 0;
	                    }
	                    optlen = sizeof(optval.ling);
	                } else {
	                    optval.i = (*env)->GetIntField(env, value, fid);
	                    optlen = sizeof(optval.i);
	                }
	
	                break;
	            }
	
	        /* Boolean -> int */
	        default :
	            optval.i = (on ? 1 : 0);
	            optlen = sizeof(optval.i);
	
	    }
	
	    if (NET_SetSockOpt(fd, level, optname, (const void *)&optval, optlen) < 0) {
	#ifdef __solaris__
	        if (errno == EINVAL) {
	            // On Solaris setsockopt will set errno to EINVAL if the socket
	            // is closed. The default error message is then confusing
	            char fullMsg[128];
	            jio_snprintf(fullMsg, sizeof(fullMsg), "Invalid option or socket reset by remote peer");
	            JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", fullMsg);
	            return;
	        }
	#endif /* __solaris__ */
	        NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
	                                      "Error setting socket option");
	    }
	}

read()

  1. 再看java代码中读取数据

    	InputStream inputStream = socket.getInputStream();
	inputStream.read()

  2. 这里inputStream的实现类是socketInputStream。执行流程如下,超时设置的值是在read()方法被调用的时候传入的

    	-->read() ①
		--> read(b, off, length, impl.getTimeout());//最终调用的都是这个方法,此时传入SO_TIMEOUT ②
		 -->native int socketRead0(FileDescriptor fd,
	                                   byte b[], int off, int len,
	                                   int timeout) ③
	        --> SocketInputStream.c中的Java_java_net_SocketInputStream_socketRead0     ④
    SocketInputStream SocketInputStream.c ① ② ③ ④ SocketInputStream SocketInputStream.c

Java_java_net_SocketInputStream_socketRead0

  1. 从下面代码分析可知,java中setSoTimeout()设置值最终是传给了linux下的select()函数，并没有通过C语言的socket选项来设置。只要在read()之前设置超时时间即可，计算超时的核心代码在NET_Timeout中

    	/*
	 * Class:     java_net_SocketInputStream
	 * Method:    socketRead0
	 * Signature: (Ljava/io/FileDescriptor;[BIII)I
	 */
	JNIEXPORT jint JNICALL
	Java_java_net_SocketInputStream_socketRead0(JNIEnv *env, jobject this,
	                                            jobject fdObj, jbyteArray data,
	                                            jint off, jint len, jint timeout)
	{
	    char BUF[MAX_BUFFER_LEN];
	    char *bufP;
	    jint fd, nread;
	
	    if (IS_NULL(fdObj)) {
	        /* shouldn't this be a NullPointerException? -br */
	        JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
	                        "Socket closed");
	        return -1;
	    } else {
	        fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
	        /* Bug 4086704 - If the Socket associated with this file descriptor
	         * was closed (sysCloseFD), then the file descriptor is set to -1.
	         */
	        if (fd == -1) {
	            JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
	            return -1;
	        }
	    }
	
	    /*
	     * If the read is greater than our stack allocated buffer then
	     * we allocate from the heap (up to a limit)
	     */
	    if (len > MAX_BUFFER_LEN) {
	        if (len > MAX_HEAP_BUFFER_LEN) {
	            len = MAX_HEAP_BUFFER_LEN;
	        }
	        bufP = (char *)malloc((size_t)len);
	        if (bufP == NULL) {
	            bufP = BUF;
	            len = MAX_BUFFER_LEN;
	        }
	    } else {
	        bufP = BUF;
	    }
	
	    if (timeout) {
	        nread = NET_Timeout(fd, timeout);
	        if (nread <= 0) {
	            if (nread == 0) {
	                JNU_ThrowByName(env, JNU_JAVANETPKG "SocketTimeoutException",
	                            "Read timed out");
	            } else if (nread == JVM_IO_ERR) {
	                if (errno == EBADF) {
	                     JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException", "Socket closed");
	                 } else {
	                     NET_ThrowByNameWithLastError(env, JNU_JAVANETPKG "SocketException",
	                                                  "select/poll failed");
	                 }
	            } else if (nread == JVM_IO_INTR) {
	                JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
	                            "Operation interrupted");
	            }
	            if (bufP != BUF) {
	                free(bufP);
	            }
	            return -1;
	        }
	    }
	
	    nread = NET_Read(fd, bufP, len);
	
	    if (nread <= 0) {
	        if (nread < 0) {
	
	            switch (errno) {
	                case ECONNRESET:
	                case EPIPE:
	                    JNU_ThrowByName(env, "sun/net/ConnectionResetException",
	                        "Connection reset");
	                    break;
	
	                case EBADF:
	                    JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
	                        "Socket closed");
	                    break;
	
	                case EINTR:
	                     JNU_ThrowByName(env, JNU_JAVAIOPKG "InterruptedIOException",
	                           "Operation interrupted");
	                     break;
	
	                default:
	                    NET_ThrowByNameWithLastError(env,
	                        JNU_JAVANETPKG "SocketException", "Read failed");
	            }
	        }
	    } else {
	        (*env)->SetByteArrayRegion(env, data, off, nread, (jbyte *)bufP);
	    }
	
	    if (bufP != BUF) {
	        free(bufP);
	    }
	    return nread;
	}

solaris/native/java/net/bsd_close.c

  1. NET_timeout代码是对select(s, timeout)的封装，使用select函数实现定时器，来判断是否超过设置的时间(setSoTimeout())

    /*
 * Wrapper for select(s, timeout). We are using select() on Mac OS due to Bug 7131399.
 * Auto restarts with adjusted timeout if interrupted by
 * signal other than our wakeup signal.
 */
int NET_Timeout(int s, long timeout) {
    long prevtime = 0, newtime;
    struct timeval t, *tp = &t;
    fd_set fds;
    fd_set* fdsp = NULL;
    int allocated = 0;
    threadEntry_t self;
    fdEntry_t *fdEntry = getFdEntry(s);

    /*
     * Check that fd hasn't been closed.
     */
    if (fdEntry == NULL) {
        errno = EBADF;
        return -1;
    }

    /*
     * Pick up current time as may need to adjust timeout
     */
    if (timeout > 0) {
        /* Timed */
        struct timeval now;
        gettimeofday(&now, NULL);
        prevtime = now.tv_sec * 1000  +  now.tv_usec / 1000;
        t.tv_sec = timeout / 1000;
        t.tv_usec = (timeout % 1000) * 1000;
    } else if (timeout < 0) {
        /* Blocking */
        tp = 0;
    } else {
        /* Poll */
        t.tv_sec = 0;
        t.tv_usec = 0;
    }

    if (s < FD_SETSIZE) {
        fdsp = &fds;
        FD_ZERO(fdsp);
    } else {
        int length = (howmany(s+1, NFDBITS)) * sizeof(int);
        fdsp = (fd_set *) calloc(1, length);
        if (fdsp == NULL) {
            return -1;   // errno will be set to ENOMEM
        }
        allocated = 1;
    }
    FD_SET(s, fdsp);

    for(;;) {
        int rv;

        /*
         * call select on the fd. If interrupted by our wakeup signal
         * errno will be set to EBADF.
         */

        startOp(fdEntry, &self);
        rv = select(s+1, fdsp, 0, 0, tp);
        endOp(fdEntry, &self);

        /*
         * If interrupted then adjust timeout. If timeout
         * has expired return 0 (indicating timeout expired).
         */
        if (rv < 0 && errno == EINTR) {
            if (timeout > 0) {
                struct timeval now;
                gettimeofday(&now, NULL);
                newtime = now.tv_sec * 1000  +  now.tv_usec / 1000;
                timeout -= newtime - prevtime;
                if (timeout <= 0) {
                    if (allocated != 0)
                        free(fdsp);
                    //返回0表示超时    
                    return 0;
                }
                prevtime = newtime;
                t.tv_sec = timeout / 1000;
                t.tv_usec = (timeout % 1000) * 1000;
            }
        } else {
            if (allocated != 0)
                free(fdsp);
            return rv;
        }

    }
}

总结

  1. Read timed out表示已经连接成功(即三次握手已经完成)，但是服务器没有及时返回数据(没有在设定的时间内返回数据)，导致读超时。
  2. java在linux中的 Read timed out并不是通过C函数setSockOpt(SO_RCVTIMEO)来设置的，而是通过select(s, timeout).来实现定时器，并抛出JNI异常来控制的
  3. java socket读超时的设置是在read()方法被调用的时候传入的，所以只要在read()调用之前设置即可
jannals
关注
  • 4
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
Socket read timed out
weixin_34228617的博客
07-02 2417
前几天同事做的一个安卓项目，我协助他搭建服务端工程，ORM框架使用mybatis-3.1.0,mvc框架使用的spring mvc（3.2.13.RELEASE），数据库为Oracle11G。项目是非常简单，直连数据库查询。刚开始SqlSessionFactory是自己写的，包括SqlSession 也是自己创建和释放。一切都很完好，自己测试O...
socket read time out解决方法_深入浅出讲解：php的socket通信
weixin_39834745的博客
11-27 4999
来源：https://www.cnblogs.com/aipiaoborensheng/p/6708963.html对TCP/IP、UDP、Socket编程这些词你不会很陌生吧？随着网络技术的发展，这些词充斥着我们的耳朵。那么我想问：什么是TCP/IP、UDP？Socket在哪里呢？Socket是什么呢？你会使用它们吗？什么是TCP/IP、UDP？TCP/IP(Transmission ...
Java中Connection timed out和Connection refused的区别讲解
08-26
今天小编就为大家分享一篇关于Java中Connection timed out和Connection refused的区别讲解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
java.net.SocketTimeoutException: Read timed out，tcp连接心跳[TCP Keep-Alive]，socket模拟http
u014644574的博客
06-02 9296
java.net.SocketTimeoutException: Read timed out，tcp连接心跳[TCP Keep-Alive]，socket模拟http
已解决java.net.SocketTimeoutException: Read timed out异常，亲测有效
最新发布
PythonAigc的博客
04-26 3270
java.net.SocketTimeoutException: Read timed out 异常通常发生在 Java 应用程序尝试通过套接字读取数据时，如果数据没有在指定的超时时间内到达，就会抛出这个异常。这可能是因为网络延迟、服务器响应慢或连接不稳定等原因造成的。 要解决这个问题，可以采取以下步骤：
java.net.SocketTimeoutException: Read timed out报警
summer089089的博客
03-23 3万+
1.报警现象 通过接口读取数据时，报警 java.net.SocketTimeoutException: Read timed out at java.net.SocketInputStream.socketRead0(Native Method) at java.net.SocketInputStream.socketRead(SocketInputStream.java:116) at java.net.SocketInputStream.read(SocketInputStream.java:1
java.net.SocketTimeoutException: Read timed out
赵KK的博客
01-31 5156
异常是的一种异常情况。它通常在进行网络通信时出现，当一个读操作在指定的时间内没有完成时，Java网络编程会抛出异常。try {// 创建Socket对象// 设置读取超时时间// 执行网络操作// ...// 处理SocketTimeoutException异常// ...// 处理其他IO异常// ...在上述代码中，我们创建了一个Socket对象，并通过方法设置读取超时时间为5秒。如果在5秒内没有完成读取操作，Java网络编程会抛出异常。
jvm参数造成http请求Read time out
守正出奇
12-06 2476
线上部署的代码，部署在测试环境突然抛出接口请求Read time out的异常。查看线上日志，接口请求正常。重新启动，部署测试环境代码都没有效果，接口还是必现Read time out。直接在测试环境服务器上执行使用curl命令执行http请求，接口正常返回，所以排查网络，第三方服务的原因。解决这类问题，最简单的方法就是抓一个正常的http请求包，抓一个Read time out异常的http请求包，对比两个的报文。但是事与愿违，容器环境禁用tcpdump命令，也就抓不了包。启动本地代码连接测试环境配置
read timed out如何解决_Java输入流read()和readline()方法对比分析【实例讲解】
weixin_30794755的博客
01-24 1万+
Hello！大家好哇，我是灰小猿，一个超会写bug的程序猿，最近一直在做项目的开发，所以很少有时间来打理博客，今天抽出一点时间来对我在开发中遇到的一些小问题和大家分享一下，在做使用TCP/IP协议进行网络通信时，遇到这样一个问题，就是在同一个局域网中，我作为客户端，以另一台电脑作为服务器进行通信时发现，两者之间可以建立C/S连接，但是对于服务器发送过来的数据，我这边以read()方法来读...
HttpClient连接时间和读取时间设置
人生最遗憾的莫过于：轻易地放弃了不该放弃的,固执地坚持了不该坚持的
03-06 4030
HttpClient连接时间 所谓连接的时候 是HttpClient发送请求的地方开始到连接上目标url主机地址的时间， 理论上是距离越短越快，线路越通畅越快，但是由于路由复杂交错，往往连接上的时间都不固定，运气不好连不上， HttpClient的默认连接时间，默认可能是1分钟，假如超过1分钟 过一会继续尝试连接，这样会有一个问题 假如遇到一个url老是连不上，会影响其他线程的线程进去， ...
java.net.SocketTimeoutException: Read timed out 异常
weixin_44974020的博客
04-22 2万+
java.net.SocketTimeoutException: Read timed out 异常解决 问题描述: 使用RestTemplate调用对接系统接口时出现该异常 原因: httpClient在获取链接时候超时 解决: 将超时时间设置更长 SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory(); // 设置超时 单位为ms requestFac
pip安装第三方包时出现socket.timeout: The read operation timed out超时问题
12-21
pip安装第三方包时出现socket.timeout: The read operation timed out超时问题 在cmd中使用pip安装第三方包时有时候会出现超时问题，这个问题的原因就是网络连接速度过慢。有的时候可能不是你的电脑网速过慢而是由于...
pip安装tensorflow出现Read timed out的解决办法
12-21
pip安装tensorflow出现Read timed out的解决办法 楼主的第一篇博客，写得不好请多谅解。 这次是楼主尝试用pip安装tensorflow，然而由于pip默认的包下载路径为python官网，所以下载速度只有几KB，等了一会之后出现了...
解决pip install的时候报错timed out的问题
09-20
今天小编就为大家分享一篇解决pip install的时候报错timed out的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
java socket长连接中解决read阻塞的3个办法
09-04
主要介绍了java socket长连接中解决read阻塞的3个办法,本文取了折中的一个方法,并给出代码实例,需要的朋友可以参考下
错误代码“err_connection_timed_out”的解决方案（某些网站不能登录，出现登陆超时）
热门推荐
小琳子要开心呀
04-26 65万+
错误代码“err_connection_timed_out”的解决方案问题描述解决方案1：清除浏览器历史记录和缓存（亲测有效）解决方案2：修改Windows主机File解决方案3：刷新或更新DNS和IP地址 （亲测有效）解决方案4：过滤防火墙和网站解决方案5：更改LAN设置 （亲测有效）解决方案6：与服务器提供商保持联系 问题描述 本人在学校使用内网，自带IP6，理论上许多外网是能够访问的，但是偏...
python爬虫解决timed out 的几种方法
qq_40138248的博客
12-10 1万+
python爬虫解决timed out 的几种方法 在请求量比较大，目标网站承重量有限的情况下可能会出现下面这种报错： Max retries exceeded with url : … Connection to www.xxxx timed out 一开始想着增加timeout的大小，但后来发现这样不仅降低了爬取速度，而且并不能有效的解决这种问题，后来在看了看别人...
http read time out一次事故
09-17 1万+
先介绍下业务背景：    最近由于业务调整，加了个上传附件的功能，采用的是http form 表单提交。使用的工具是httpclient-4.4.1,MultipartEntityBuilder方式直接提交。每次上传文件成功之后，就大概率出现后面的post请求read time out。整个文件大小在100kb左右，耗费的时间大概是1s到2s。抓包发现每次要是文件上传出现tcp Retran
RestTemplate的Read Time out问题
weixin_45453028的博客
05-12 8726
在做微服务开发的过程中，A服务调用B服务，A服务出现了“java.net.SocketTimeoutException: Read timed out ”错误。
io异常 socket read timed out
06-07
这个异常通常表示在读取数据时，Socket连接超时了。这可能是由于网络问题、服务器负载高、防火墙等原因导致的。 为了解决这个问题，你可以尝试以下几个方法： 1. 检查网络连接是否正常，确保你的网络连接稳定。 2. 增加Socket的读取超时时间，可以使用Socket的setSoTimeout()方法来设置超时时间。例如，socket.setSoTimeout(5000)，将超时时间设置为5秒。 3. 检查服务器负载，如果服务器负载过高，可以尝试增加服务器的性能或者使用负载均衡来分散负载。 4. 检查防火墙设置，确保防火墙允许你的应用程序访问网络。 希望这些方法能帮助你解决这个问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值