Java socket中关闭IO流后，发生什么事？（以关闭输出流为例）

声明：该博文以socket中，关闭输出流为例进行说明。

 

为了方便讲解，我们把DataOutputstream dout = new DataOutputStream(new BufferedOutputStream(mySocket.getOutputStream()));中的dout做为Socket输出流的代言。同样的，din是输入流的代言。

可以造成dout被关闭的操作有：

1、调用dout.close();或din.close();因为使用这种流关闭，会造成socket被关闭，所以输入输出流都将不可再用。

2、调用socket.close();

3、调用socket.shutdownOutputStream();单方面关闭dout，此时din还可正常使用。

 

以下，我将对socket中关闭输出流进行3个测试：

输出流关闭测试一：socket关闭吗？
输出流关闭测试二：该流是否可以重新开启？
输出流关闭测试三：输出缓冲区里的数据是丢弃，还是发送？

 测试结果如下：

测试一：dout.close();会造成socket被关闭，但socket.shutdownOutputStream()不会。

测试二：不可以，会抛出异常！

测试三：丢弃

客户端程序：

[java] view
plain copy

  1. package com.test2;  
  2. import java.io.*;  
  3. import java.net.*;  
  4. /** 
  5. * @ClassName: SocketTest 
  6. * @Description: 测试Socket中，流关闭后，socket是否关闭？是否可重开流？输出缓存区的数据是发送出去，还是丢弃？ 
  7. * @author 慢跑学Android 
  8. * @date 2011-11-12 上午11:15:21 
  9. *  
  10. */  
  11. public class SocketTest {  
  12.     Socket mySocket;  
  13.     DataOutputStream dout;  
  14.     public static void main(String[] args){  
  15.         new SocketTest();  
  16.     }  
  17.       
  18.     public SocketTest(){  
  19.         // 输出流关闭的测试一：socket关闭吗？  
  20.         test1();  
  21.         // 输出流关闭测试二：该流是否可以重新开启？  
  22.         test2();  
  23.         // 输出流关闭测试三：输出缓冲区里的数据是丢弃，还是发送？  
  24.         test3();  
  25.     }  
  26.   
  27.     private void test1() {  
  28.         // 输出流关闭的测试一：socket关闭吗？  
  29.         System.out.println("\n****2种方式关闭输出流，Socket是否关闭？***\n");  
  30.         try {  
  31.             mySocket = new Socket("27.154.122.233",9999);  
  32.         } catch (UnknownHostException e) {  
  33.             e.printStackTrace();  
  34.         } catch (IOException e) {  
  35.             e.printStackTrace();  
  36.         }  
  37.           
  38.         try {  
  39.             dout = new DataOutputStream(new BufferedOutputStream(mySocket.getOutputStream()));  
  40.             //下面这一句主要是用来证明socket确实处于开启状态  
  41.             System.out.println("输出流刚打开,Socket是否关闭？" + mySocket.isClosed());  
  42.             mySocket.shutdownOutput();  
  43.             System.out.println("使用shutdownOutput关闭输出流，Socket是否关闭？" + mySocket.isClosed());  
  44.             dout.close();  
  45.             System.out.println("使用close关闭输出流，Socket是否关闭？" + mySocket.isClosed());  
  46.         } catch (IOException e) {  
  47.             e.printStackTrace();  
  48.         }  
  49.     }  
  50.   
  51.     private void test2() {  
  52.         // 输出流关闭测试二：使用shutdownOutputStream后，输出流是否可以重新开启？  
  53.         System.out.println("\n****使用shutdownOutputStream后，输出流是否可以重新开启？***\n");  
  54.         try {  
  55.             mySocket = new Socket("27.154.122.233",9999);  
  56.         } catch (UnknownHostException e) {  
  57.             e.printStackTrace();  
  58.         } catch (IOException e) {  
  59.             e.printStackTrace();  
  60.         }  
  61.           
  62.         try {  
  63.             dout = new DataOutputStream(new BufferedOutputStream(mySocket.getOutputStream()));  
  64.             mySocket.shutdownOutput();  
  65.             // 重开输出流  
  66.             dout = new DataOutputStream(mySocket.getOutputStream());  
  67.             dout.writeUTF("是否允许我重开？");  
  68.             // 清空输出缓存，确保当dout通道没问题时，消息可以到达服务器  
  69.             dout.flush();  
  70.         } catch (IOException e) {  
  71.             e.printStackTrace();  
  72.         } finally {  
  73.             try {  
  74.                 mySocket.close();  
  75.             } catch (IOException e) {  
  76.                 e.printStackTrace();  
  77.             }  
  78.         }  
  79.     }  
  80.       
  81.     private void test3(){  
  82.         // 输出流关闭测试三：输出缓冲区里的数据是丢弃，还是发送？  
  83.         System.out.println("\n***输出缓冲区里的数据是丢弃，还是发送？****\n");  
  84.         try {  
  85.             mySocket = new Socket("27.154.122.233",9999);  
  86.         } catch (UnknownHostException e) {  
  87.             e.printStackTrace();  
  88.         } catch (IOException e) {  
  89.             e.printStackTrace();  
  90.         }  
  91.           
  92.         try {  
  93.             dout = new DataOutputStream(new BufferedOutputStream(mySocket.getOutputStream()));  
  94.             dout.writeUTF("shutdownOutput后，数据发得得出去吗？");  
  95.             mySocket.shutdownOutput();  
  96.         } catch (IOException e) {  
  97.             e.printStackTrace();  
  98.         }  
  99.     }  
  100. }  

服务器端程序：

 

[java] view
plain copy

  1. /**    
  2. * @Title: ServerSocketTest.java 
  3. * @Package com.test1 
  4. * @Description: TODO(该文件为”Socket中，流关闭后，发生什么事“的Sever测试端) 
  5. * @author 慢跑学Android 
  6. * @date 2011-11-12 上午11:31:05 
  7. * @version V1.0    
  8. */  
  9. package com.test1;  
  10.   
  11. import java.io.*;  
  12. import java.net.*;  
  13.   
  14. public class ServerSocketTest extends Thread{  
  15.     private ServerSocket myServerSocket;  
  16.     private final int PORT = 9999;  
  17.     public static void main(String[] args){  
  18.         ServerSocketTest sst = new ServerSocketTest();  
  19.         sst.start();  
  20.     }  
  21.       
  22.     public ServerSocketTest(){  
  23.         // 初始化一个ServeSocket端  
  24.         try {  
  25.             myServerSocket = new ServerSocket(PORT);  
  26.         } catch (IOException e) {  
  27.             e.printStackTrace();  
  28.         }  
  29.     }  
  30.       
  31.     public void run(){  
  32.         while(true){  
  33.             System.out.println("我是服务器，我在9999端口监听....");  
  34.             try {  
  35.                 Socket socket = myServerSocket.accept();  
  36.                 DataInputStream din = new DataInputStream(new BufferedInputStream(socket.getInputStream()));  
  37.                 String msgIn = din.readUTF();  
  38.                 System.out.println(msgIn.trim());  
  39.             } catch (IOException e) {  
  40.                 e.printStackTrace();  
  41.             }  
  42.         }  
  43.     }  
  44. }  

说明一点：

在test3()中，因为dout = new DataOutputStream(newBufferedOutputStream(mySocket.getOutputStream()));使用了Buffered，所以在dout.writeUTF()方法后，如果没有使用dout.flush();数据会存在输出缓存中，不会发送出去的。

如果我们队dout的声明是，dout = new DataOutputStream(mySocket.getOutputStream());那么，数据会立即发送出去。（除非，对方没有调用read()来读取数据，且数据量极大，超过了对方的输入缓存。不过，此时dout.writeUTF();这里会堵塞。）


以下是程序运行后，客户端与服务器各自的控制台输出情况：

----------------------------------客户端--------------------------

java.net.SocketException: Socket output is shutdown
 at java.net.Socket.getOutputStream(Unknown Source)
 at com.test2.SocketTest.test2(SocketTest.java:66)
 at com.test2.SocketTest.<init>(SocketTest.java:22)
 at com.test2.SocketTest.main(SocketTest.java:15)

****2种方式关闭输出流，Socket是否关闭？***

输出流刚打开,Socket是否关闭？false
使用shutdownOutput关闭输出流，Socket是否关闭？false
使用close关闭输出流，Socket是否关闭？true

****使用shutdownOutputStream后，输出流是否可以重新开启？***

***输出缓冲区里的数据是丢弃，还是发送？****

 

---------------------------------服务器------------------------------

我是服务器，我在9999端口监听....
我是服务器，我在9999端口监听....
java.io.EOFException
 at java.io.DataInputStream.readUnsignedShort(Unknown Source)
 at java.io.DataInputStream.readUTF(Unknown Source)
 at java.io.DataInputStream.readUTF(Unknown Source)
 at com.test1.ServerSocketTest.run(ServerSocketTest.java:37)
java.io.EOFException
 at java.io.DataInputStream.readUnsignedShort(Unknown Source)
 at java.io.DataInputStream.readUTF(Unknown Source)
 at java.io.DataInputStream.readUTF(Unknown Source)
 at com.test1.ServerSocketTest.run(ServerSocketTest.java:37)
java.io.EOFException
 at java.io.DataInputStream.readUnsignedShort(Unknown Source)

我是服务器，我在9999端口监听....

 at java.io.DataInputStream.readUTF(Unknown Source)
 at java.io.DataInputStream.readUTF(Unknown Source)
 at com.test1.ServerSocketTest.run(ServerSocketTest.java:37)

时间： 2024-04-26 23:16:25

Java socket中关闭IO流后，发生什么事？（以关闭输出流为例）的相关文章

too many open files-Log4J中Logger如何关闭IO流

问题描述 Log4J中Logger如何关闭IO流 在项目由于日志需要对日志进行扩展,根据交易号和日期生成logger对象放入队列中,每天会清除之前的日志对象,刚开始没有发现问题,大约到了1个月左右,生产中报了java.net.SocketException:too many open files异常,首先整个系统中除了日志外,只有读取配置文件的两个本地IO操作,其他的是网络IO,其次在早上没有大规模并发请求,除了心跳报文外,其他无请求,综合上述可以将问题定位在日志上.仔细想每天我只是把日志对象从

io流-java中的IO流使用情况

问题描述 java中的IO流使用情况 java中有很多读取和写入文件的操作 像FileWirter Writer Reader BufferWriter 等 我一直区分不清这几个的特点,有没有大神帮忙处理下,通常什么情况使用什么比较好.各有那些优点和缺点 解决方案 你可以上网搜索哦下,很多的 解决方案二: 有的有缓冲区,有的没有,有的没有:有的可以操纵字符文件,有的可以操纵字节文件,你可以按照这个进行分类 解决方案三: 这是我自己整理的,你可以参考下http://blog.csdn.net/ev

io流-java问题：学习IO流课程的Filewriter时遇到了实操跟老师所讲，并不一致的情况

问题描述 java问题:学习IO流课程的Filewriter时遇到了实操跟老师所讲,并不一致的情况 老师讲课时说,要在我下图的箭头那个位置多写个",true",代表数据追加,以此可以分批次writer数据到文件里,否则新数据会覆盖前面的旧数据,视频演示时的确也符合他的这个说法,但我下来自己练习时发现,不用加true它自己就会追加数据耶?这是怎么回事,用的软件版本都是一样的,怎么会和教程里不同 解决方案 1楼说的没错,不知你谁否已经理解. 调用一次new Filewriter("

Java 1.1的IO流

到这个时候,大家或许会陷入一种困境之中,怀疑是否存在IO流的另一种设计方案,并可能要求更大的代码量.还有人能提出一种更古怪的设计吗?事实上,Java 1.1对IO流库进行了一些重大的改进.看到Reader和Writer类时,大多数人的第一个印象(就象我一样)就是它们用来替换原来的InputStream和OutputStream类.但实情并非如此.尽管不建议使用原始数据流库的某些功能(如使用它们,会从编译器收到一条警告消息),但原来的数据流依然得到了保留,以便维持向后兼容,而且: (1) 在老式层

java socket 文件传输-java socket 传文件文件接收后不能打开

问题描述 java socket 传文件文件接收后不能打开 java socket传文件,客户端将文件读取到byte[]中,然后用Map对相关内容进行包装之后输出到服务器端,但服务器端读取文件内容的循环除第一次读取的Map是客户端写入过来的内容外,从第二次循环开始Map的内容都跟第一次一样的,请问怎么回事? 服务器端代码: `public void run() { ObjectInputStream is = null; OutputStream os = null; byte cache[]

Java IO流学习总结一：输入输出流

Java IO流学习总结一:输入输出流 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/54292148 本文出自[赵彦军的博客] Java流类图结构: 流的概念和作用 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作. IO流的分类 根据处理数据类型的不同分为:字符流和字节流 根据数据流向不同分为:输入

Java基础-19总结IO流，异常try…catch，throws，File类

1:异常(理解) (1)程序出现的不正常的情况. (2)异常的体系 Throwable |--Error 严重问题,我们不处理. |--Exception |--RuntimeException 运行期异常,我们需要修正代码 |--非RuntimeException 编译期异常,必须处理的,否则程序编译不通过 package cn.itcast_01; /*  * 异常:程序出现了不正常的情况.  *   * 举例:今天天气很好,班长出去旅游.骑着自行车,去山里面呼吸新鲜空气.  *  问题1:

Java Mail 如何发送IO 流

问题描述 JavaMail 发送邮件的时候,如何把程序中读出来的IO流直接发出去,而不是保存成临时文件,在通过MimeBodyPart.attachFile(new File(filePath));这种方式发?? 解决方案 不可以!邮件SMTP协议里,邮件的头.体都是字符,所以邮件都是做Base64编码的,是字符,所以不可能有二进制流的形式.邮件的附件也会被编码,所以没有二进制流的发送方式.

java笔记七：IO流之字节流与字节缓冲流

在I/O类库中,java.io.InputStream和java.io.OutputStream分别表示字节输入流和字节输出流,它们都是抽象类,不能实例化,数据流中的最小单位是字节,所以叫做字节流. 一.InputStream中的读取数据的方法如下: 1 .int read() 功能:读取一个字节的数据,并且返回读到得数据,如果返回-1,则表示读到输入流的末尾. 2.int read(byte[] b) 功能:从输入流中读取一定量的字节,并将其存储在字节数组b中,返回实际读取的字节数,如果返回-