socket setSoTimeout方法

最新推荐文章于 2024-06-18 12:13:10 发布
最新推荐文章于 2024-06-18 12:13:10 发布
阅读量4.4w 收藏 28
点赞数 7
分类专栏： socket网络编程 文章标签： socket


做网络编程的人对setSoTimeout方法一定很熟悉，都知道是设置连接的超时时间！

但是我在网上找资料时发现很多人把这个超时时间理解成了链路的超时时间！我看了一下JDK 关于这个方法的说明，其实根本不是链路的超时时间！

 

Java代码 复制代码  收藏代码
  1. setSoTimeout  
  2. public void setSoTimeout(int timeout)  
  3.     throws SocketException启用/禁用带有指定超时值的 SO_TIMEOUT，以毫秒为单位。将此选项设为非零的超时值时，在与此 Socket 关联的 InputStream 上调用 read() 将只阻塞此时间长度。  
  4.     如果超过超时值，将引发 java.net.SocketTimeoutException，虽然 Socket 仍旧有效。选项必须在进入阻塞操作前被启用才能生效。  
  5.     超时值必须是 > 0 的数。超时值为 0 被解释为无穷大超时值。   
  6. 参数：  
  7. timeout - 指定的以毫秒为单位的超时值。   
  8. 抛出：   
  9. SocketException - 如果底层协议出现错误，例如 TCP 错误。  
  10. 从以下版本开始：   
  11. JDK 1.1   
  12. 另请参见：  
  13. getSoTimeout()  
setSoTimeout
public void setSoTimeout(int timeout)
	throws SocketException启用/禁用带有指定超时值的 SO_TIMEOUT，以毫秒为单位。将此选项设为非零的超时值时，在与此 Socket 关联的 InputStream 上调用 read() 将只阻塞此时间长度。
	如果超过超时值，将引发 java.net.SocketTimeoutException，虽然 Socket 仍旧有效。选项必须在进入阻塞操作前被启用才能生效。
	超时值必须是 > 0 的数。超时值为 0 被解释为无穷大超时值。 
参数：
timeout - 指定的以毫秒为单位的超时值。 
抛出： 
SocketException - 如果底层协议出现错误，例如 TCP 错误。
从以下版本开始： 
JDK 1.1 
另请参见：
getSoTimeout()

 

其实说白了他只是read方法的超时时间，这个方法是堵塞的！

 

写个小例子验证一下：

服务端，收到一个请求后处理，但是只处理一个请求，处理完毕后结束：

Java代码 复制代码  收藏代码
  1. package socket;  
  2. import java.io.ByteArrayOutputStream;  
  3. import java.io.InputStream;  
  4. import java.net.InetSocketAddress;  
  5. import java.net.ServerSocket;  
  6. import java.net.Socket;  
  7. import java.net.SocketAddress;  
  8. import java.net.SocketException;  
  9. import java.net.SocketTimeoutException;  
  10. import java.text.SimpleDateFormat;  
  11. import java.util.Arrays;  
  12. import java.util.Date;  
  13. public class SocketService {  
  14.     public static void main(String[] args) {  
  15.         try {  
  16.             SocketAddress address = new InetSocketAddress("192.168.9.155", 30001);  
  17.             // 启动监听端口 8001  
  18.             ServerSocket ss = new ServerSocket();  
  19.             ss.bind(address);  
  20.             // 接收请求  
  21.             Socket s = ss.accept();  
  22.             new Thread(new T(s)).start();  
  23.         } catch (Exception e) {  
  24.             e.printStackTrace();  
  25.         }  
  26.     }  
  27. }  
  28. class T implements Runnable {  
  29.     public void run() {  
  30.         try {  
  31.             System.out.println(socket.toString());  
  32.             socket.setKeepAlive(true);  
  33.             socket.setSoTimeout(5 * 1000);  
  34.             String _pattern = "yyyy-MM-dd HH:mm:ss";  
  35.             SimpleDateFormat format = new SimpleDateFormat(_pattern);  
  36.             while (true) {  
  37.                 System.out.println("开始：" + format.format(new Date()));  
  38.                 try {  
  39.                     InputStream ips = socket.getInputStream();  
  40.                     ByteArrayOutputStream bops = new ByteArrayOutputStream();  
  41.                     int data = -1;  
  42.                     while((data = ips.read()) != -1){  
  43.                         System.out.println(data);  
  44.                         bops.write(data);  
  45.                     }  
  46.                     System.out.println(Arrays.toString(bops.toByteArray()));  
  47.                 }catch(SocketTimeoutException e){  
  48.                     e.printStackTrace();  
  49.                 }catch(SocketException e){  
  50.                     e.printStackTrace();  
  51.                 } catch (Exception e) {  
  52.                     e.printStackTrace();  
  53.                 }  
  54.                 Thread.sleep(1000);  
  55.                 System.out.println(socket.isBound()); // 是否邦定  
  56.                 System.out.println(socket.isClosed()); // 是否关闭  
  57.                 System.out.println(socket.isConnected()); // 是否连接  
  58.                 System.out.println(socket.isInputShutdown()); // 是否关闭输入流  
  59.                 System.out.println(socket.isOutputShutdown()); // 是否关闭输出流  
  60.                 System.out.println("结束：" + format.format(new Date()));  
  61.             }  
  62.         } catch (Exception e) {  
  63.             e.printStackTrace();  
  64.         }  
  65.     }  
  66.     private Socket socket = null;  
  67.     public T(Socket socket) {  
  68.         this.socket = socket;  
  69.     }  
  70.     public Socket getSocket() {  
  71.         return socket;  
  72.     }  
  73.     public void setSocket(Socket socket) {  
  74.         this.socket = socket;  
  75.     }  
  76. }  
package socket;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class SocketService {
	public static void main(String[] args) {
		try {
			SocketAddress address = new InetSocketAddress("192.168.9.155", 30001);
			// 启动监听端口 8001
			ServerSocket ss = new ServerSocket();
			ss.bind(address);
			// 接收请求
			Socket s = ss.accept();
			new Thread(new T(s)).start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class T implements Runnable {
	public void run() {
		try {
			System.out.println(socket.toString());
			socket.setKeepAlive(true);
			socket.setSoTimeout(5 * 1000);
			String _pattern = "yyyy-MM-dd HH:mm:ss";
			SimpleDateFormat format = new SimpleDateFormat(_pattern);
			while (true) {
				System.out.println("开始：" + format.format(new Date()));
				try {
					InputStream ips = socket.getInputStream();
					ByteArrayOutputStream bops = new ByteArrayOutputStream();
					int data = -1;
					while((data = ips.read()) != -1){
						System.out.println(data);
						bops.write(data);
					}
					System.out.println(Arrays.toString(bops.toByteArray()));
				}catch(SocketTimeoutException e){
					e.printStackTrace();
				}catch(SocketException e){
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}
				Thread.sleep(1000);
				System.out.println(socket.isBound()); // 是否邦定
				System.out.println(socket.isClosed()); // 是否关闭
				System.out.println(socket.isConnected()); // 是否连接
				System.out.println(socket.isInputShutdown()); // 是否关闭输入流
				System.out.println(socket.isOutputShutdown()); // 是否关闭输出流
				System.out.println("结束：" + format.format(new Date()));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	private Socket socket = null;
	public T(Socket socket) {
		this.socket = socket;
	}
	public Socket getSocket() {
		return socket;
	}
	public void setSocket(Socket socket) {
		this.socket = socket;
	}
}

 

 

 第一个客户端，连接后一直保持连接对象的存活，但是不发送数据，服务端打印：

Java代码 复制代码  收藏代码
  1. package socket;  
  2. import java.net.Socket;  
  3. public class Client {  
  4.     public static void main(String[] args) {  
  5.         try {  
  6.             Socket socket = new Socket("192.168.9.155", 30001);  
  7.             socket.setKeepAlive(true);  
  8.             while(true && null != socket){  
  9.                 Thread.sleep(10 * 1000);  
  10.             }  
  11.         } catch (Exception e) {  
  12.             e.printStackTrace();  
  13.         }  
  14.     }  
  15. }  
package socket;
import java.net.Socket;
public class Client {
	public static void main(String[] args) {
		try {
			Socket socket = new Socket("192.168.9.155", 30001);
			socket.setKeepAlive(true);
			while(true && null != socket){
				Thread.sleep(10 * 1000);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

打印如下，可以看到链路一直是活的，间隔超时时间的间隔就打印一组异常信息： 

 

Java代码 复制代码  收藏代码
  1. Socket[addr=/192.168.9.155,port=3017,localport=30001]  
  2. 开始：2012-11-14 11:15:30  
  3. java.net.SocketTimeoutException: Read timed out  
  4.     at java.net.SocketInputStream.socketRead0(Native Method)  
  5.     at java.net.SocketInputStream.read(Unknown Source)  
  6.     at java.net.SocketInputStream.read(Unknown Source)  
  7.     at socket.T.run(SocketService.java:42)  
  8.     at java.lang.Thread.run(Unknown Source)  
  9. true  
  10. false  
  11. true  
  12. false  
  13. false  
  14. 结束：2012-11-14 11:15:36  
  15. 开始：2012-11-14 11:15:36  
  16. java.net.SocketTimeoutException: Read timed out  
  17.     at java.net.SocketInputStream.socketRead0(Native Method)  
  18.     at java.net.SocketInputStream.read(Unknown Source)  
  19.     at java.net.SocketInputStream.read(Unknown Source)  
  20.     at socket.T.run(SocketService.java:42)  
  21.     at java.lang.Thread.run(Unknown Source)  
  22. true  
  23. false  
  24. true  
  25. false  
  26. false  
  27. 结束：2012-11-14 11:15:42  
  28. 开始：2012-11-14 11:15:42  
Socket[addr=/192.168.9.155,port=3017,localport=30001]
开始：2012-11-14 11:15:30
java.net.SocketTimeoutException: Read timed out
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.read(Unknown Source)
	at java.net.SocketInputStream.read(Unknown Source)
	at socket.T.run(SocketService.java:42)
	at java.lang.Thread.run(Unknown Source)
true
false
true
false
false
结束：2012-11-14 11:15:36
开始：2012-11-14 11:15:36
java.net.SocketTimeoutException: Read timed out
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.read(Unknown Source)
	at java.net.SocketInputStream.read(Unknown Source)
	at socket.T.run(SocketService.java:42)
	at java.lang.Thread.run(Unknown Source)
true
false
true
false
false
结束：2012-11-14 11:15:42
开始：2012-11-14 11:15:42

  

 然后我们编写一个客户端，连接后马上关闭连接，也不发送任何数据：

Java代码 复制代码  收藏代码
  1. package socket;  
  2. import java.net.Socket;  
  3. public class Client {  
  4.     public static void main(String[] args) {  
  5.         try {  
  6.             Socket socket = new Socket("192.168.9.155", 30001);  
  7.             socket.setKeepAlive(true);  
  8.         } catch (Exception e) {  
  9.             e.printStackTrace();  
  10.         }  
  11.     }  
  12. }  
package socket;
import java.net.Socket;
public class Client {
	public static void main(String[] args) {
		try {
			Socket socket = new Socket("192.168.9.155", 30001);
			socket.setKeepAlive(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

打印如下：

Java代码 复制代码  收藏代码
  1. 开始：2012-11-14 11:17:42  
  2. java.net.SocketException: Connection reset  
  3.     at java.net.SocketInputStream.read(Unknown Source)  
  4.     at java.net.SocketInputStream.read(Unknown Source)  
  5.     at socket.T.run(SocketService.java:42)  
  6.     at java.lang.Thread.run(Unknown Source)  
  7. true  
  8. false  
  9. true  
  10. false  
  11. false  
  12. java.net.SocketException: Connection reset  
  13.     at java.net.SocketInputStream.read(Unknown Source)  
  14.     at java.net.SocketInputStream.read(Unknown Source)  
  15.     at socket.T.run(SocketService.java:42)  
  16.     at java.lang.Thread.run(Unknown Source)  
  17. 结束：2012-11-14 11:17:43  
  18. 开始：2012-11-14 11:17:43  
  19. true  
  20. false  
  21. true  
  22. false  
  23. false  
  24. 结束：2012-11-14 11:17:44  
开始：2012-11-14 11:17:42
java.net.SocketException: Connection reset
	at java.net.SocketInputStream.read(Unknown Source)
	at java.net.SocketInputStream.read(Unknown Source)
	at socket.T.run(SocketService.java:42)
	at java.lang.Thread.run(Unknown Source)
true
false
true
false
false
java.net.SocketException: Connection reset
	at java.net.SocketInputStream.read(Unknown Source)
	at java.net.SocketInputStream.read(Unknown Source)
	at socket.T.run(SocketService.java:42)
	at java.lang.Thread.run(Unknown Source)
结束：2012-11-14 11:17:43
开始：2012-11-14 11:17:43
true
false
true
false
false
结束：2012-11-14 11:17:44

 

异常是不一样的，不一样的还有，如果是超时，则五秒钟循环一次，然后是连接中断，则不在循环马上再报错，因为连接已经挂了！但是打印这个连接还是有效的，这个我也不知道怎么回事！

 

所以，如果大家理解为超时时间内没有数据连接就自动关闭或失效，那么这个理解就非常有问题了！

 

请您到ITEYE看我的原创：http://cuisuqiang.iteye.com

或支持我的个人博客，地址：http://www.javacui.com

 


                               
评论
6 楼 fjjiaboming 2015-08-21  
Java代码 复制代码  收藏代码
  1. package socket;  
  2. import java.net.Socket;  
  3. public class Client {  
  4.     public static void main(String[] args) {  
  5.         try {  
  6.             Socket socket = new Socket("192.168.9.155", 30001);  
  7.             socket.setKeepAlive(true);  
  8.         } catch (Exception e) {  
  9.             e.printStackTrace();  
  10.         }  
  11.     }  
  12. }  
package socket;
import java.net.Socket;
public class Client {
	public static void main(String[] args) {
		try {
			Socket socket = new Socket("192.168.9.155", 30001);
			socket.setKeepAlive(true);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

你这哪里有关闭?
5 楼 crazysummer 2014-01-23  
博主，想问下，如果我的客户端用Socket短连接传输较大的数据，并且要从服务器端获得返回信息，那个这个超时的时间是不是要设置得比我这个数据的传输时间更大呢？
4 楼 xiaoZ5919 2012-11-15  
socket的读写是阻塞的，soTimeout是socket读写超时，而不是链接超时。
connection reset是由于在一个半关闭的connection上读取数据导致，client已经关闭但是server端没有关闭。http://xiaoz5919.iteye.com/blog/1685138
3 楼 cuisuqiang 2012-11-14  
huzhenyu 写道
直接拔网线需要使用心脏机制，A给B一个验证消息若A能正常收到回执消息，则证明A网络正常。

心跳包我尝试了，没用，网线掉后还能正常发送！但是一段时间后才会心跳异常！
2 楼 huzhenyu 2012-11-14  
直接拔网线需要使用心脏机制，A给B一个验证消息若A能正常收到回执消息，则证明A网络正常。
1 楼 cuisuqiang 2012-11-14  
还有一个问题，那就是如果是程序或网卡主动断连接，那能捕获连接中断的异常，但是如果是把网线的话就获得不了！
不知道这种情况下如何判定网络的中断！有知道的请发表一下！
qq_23013625
关注
专栏目录
深入剖析阻塞式socket的timeout
yinshipin007的博客
03-06 4780
一个tcp连接建立后，如果一端的物理机突然宕机，另外一端是完全不知情的，它会像往常一样继续发送相关报文，直到超时时间到了才返回。而如果只是进程宕掉，在进程退出的时候，操作会负责回收这个进程所属的所有tcp连接，在这时会向这些tcp连接的对端发送FIN报文，表示要关闭连接了，这时候对端是可以知道连接已经关闭的。在有机器宕机的情况下，如果连接超时时间设置的比较长，而我们客户端的线程池又比较小，就很可能大多数的线程都在等待建立连接，过了较长时间才发现连接不上，影响应用的整体吞吐量。但是可以大致认为是一致的。
Android使用socket创建简单TCP连接的方法
09-02
当接收到客户端的连接时，通过`accept()`方法获取一个`Socket`对象，用以读取客户端发送的数据，并向客户端发送响应。 接下来，我们关注Android客户端的实现。在Android应用中，我们通常在一个单独的线程里执行...
socket详解--setSoTimeout()
weixin_43710268的博客
11-16 1万+
jdk文档的描述: public void setSoTimeout(int timeout) throws SocketException 使用指定的超时时间启用/禁用SO_TIMEOUT（以毫秒为单位）。 使用此选项设置为非零超时时，与此Socket相关联的InputStream上的read（）调用将仅阻止此时间。 如果超时超时，则引发java.net.SocketTimeoutException ，尽管Socket仍然有效。 必须先启用该选项才能进入阻止操作才能生效。 超时时间必须为> 0 。
【Java】解决Java报错：SocketTimeoutException during Network Communication
最新发布
Easonmax的博客
06-18 1827
是Java中常见的检查型异常，在网络通信过程中尤其容易发生。本文详细介绍了其产生原因，并提供了多种解决方案，包括合理设置超时时间、使用重试机制、使用NIO和异步通信、以及使用高层次的网络通信库。通过遵循最佳实践，开发者可以有效地避免和处理这种异常，提高代码的健壮性和可靠性。
Java网络编程 ServeSocket、Socket 方法 setSoTimeout() 详解
csdn_bajie
07-15 3418
Java网络编程 ServeSocket、Socket 方法 setSoTimeout() 详解
Socket.setSoTimeout()方法的使用
热门推荐
梦一样的博客，神话般的感觉
03-06 6万+
setSoTimeout()这个方法所设置的超时时间还未结束的时候，可以通过socket.getInputStream()获得的InputStream对象进行二次读取。在二次读取的时候，如果客户端如果没有进行二次请求，InputStream对象二次读取的时候会死锁，直到客户端二次请求时才会继续运行，但是一旦超过setSoTimeout()方法所设置的超时时间，便会抛出java.net.Socket
java setsotimeout_socket.setSoTimeout(1000);
weixin_36060917的博客
02-16 249
import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.Inet4Address;import java.net.InetSocketAddress;import java.net.ServerSocket;import java.net.Socket;imp...
socket setSoTimeout
06-08
socket.setSoTimeout() 方法是用来设置套接字的读取数据超时时间，也就是说如果在指定的时间内没有读取到数据，就会抛出一个 SocketTimeoutException 异常。此方法的参数单位是毫秒。 举个例子，如果你调用了 ...
socket.setSoTimeout
05-13
socket.setSoTimeout() 是一个 Java 中的方法，它用于设置在阻塞套接字上调用 read() 方法时的超时时间。如果在指定的超时时间内没有从套接字读取任何数据，则 read() 方法将抛出一个 SocketTimeoutException 异常。...
socket.setsotimeout
03-16
socket.setsotimeout是一个Python中的socket库函数，用于设置socket的超时时间。该函数可以设置socket在接收或发送数据时的超时时间，如果在规定时间内没有接收或发送数据，则会抛出一个socket.timeout异常。这个...
java的TelnetClient的setSoTimeout方法设置为什么产生空指针
06-09
`TelnetClient` 是 Java 中用于创建 Telnet 连接的类，其中的 `setSoTimeout` 方法用于设置 Socket 超时时间。如果在调用此方法之前没有先通过 `connect` 等方法建立连接，那么会抛出 `NullPointerException` 异常，...
java socket参数详解:SoTimeout
清风小阁
03-09 2万+
设置socket调用InputStream读数据的超时时间，以毫秒为单位，如果超过这个时候，会抛出java.net.SocketTimeoutException。 当输入流的read方法被阻塞时，如果设置timeout（timeout的单位是毫秒），那么系统在等待了timeout毫秒后会抛出一个InterruptedIOException例外。在抛出例外后，输入流并未关闭，你可以继续通过read
Socket的setSoTimeout() 和 setSoLinger(boolean on, int linger)
haoranhaoshi的博客
08-03 656
socket的getInputStream()用来接收响应，有响应时不再阻塞，可以inputStream可以read。socket的setSoTimeout()设置响应超时时间，不是read的时间，而是没有byte可以read的时间，超过这个时间则报socket time out。 setSoLinger(boolean 调用socket的close()方法后，是否立刻断开连接, int 如果不...
socket setSoTimeOut
u012427018的博客
11-24 976
设置SocketServer中的setSoTimeOut(10000)表示服务端启动后，如果10秒内没有请求这个服务端的话，抛异常 Socket设置setSoTimeOut(10000)表示10秒内没有接收到数据化客户端强行断开连接。
java socket 通过setSoTimeout函数实现计时阻塞
m0_61602185的博客
11-28 571
java socket 可以用 socket.setSoTimeout()方法实现计时阻塞，只对read方法起作用，当read阻塞时间超过setSoTimeout设置的时间，read方法会抛出异常，用try catch捕捉到异常以后，程序会继续执行。//继续执行下面的程序。
【计算机网络】Socket的SO_TIMEOUT与连接超时时间
morris
02-04 4643
SO_TIMEOUT选项是Socket的一个选项，用于设置读取数据的超时时间。它指定了在读取数据时等待的最长时间，如果在指定的时间内没有数据可读取，将抛出SocketTimeoutException异常。
setsotimeout java_Java：setSoTimeout和多线程问题
weixin_42475535的博客
02-21 279
我正在编写一个服务器，它应该保持与客户端的连接，只要它通过套接字发送命令 . 每次接受新连接时， soTimeout 都设置为 60000 ，套接字将传递给提交给线程池的Runnable .这是接受新连接的主线程：ExecutorService tpl = Executors.newFixedThreadPool(10);while (!isCancelled) {try {ServerSocke...
socket.setSoTimeout(1000);
weixin_30561177的博客
04-01 681
这个用来设置与socket的inputStream相关的read操作阻塞的等待时间，超过设置的时间了，假如还是阻塞状态，会抛出异常java.net.SocketTimeoutException: Read timed out 这里的阻塞不是指read的时间长短，可以理解为没有数据可读，线程一直在这等待 import java.io.IOException; import java....
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值