声明:该博文以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()不会。

测试二:不可以,会抛出异常!

测试三:丢弃

客户端程序:

 

01.package com.test2;  
02.import java.io.*;  
03.import java.net.*;  
04./** 
05.* @ClassName: SocketTest 
06.* @Description: 测试Socket中,流关闭后,socket是否关闭?是否可重开流?输出缓存区的数据是发送出去,还是丢弃? 
07.* @author 慢跑学Android 
08.* @date 2011-11-12 上午11:15:21 
09.*  
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.}

 

 

服务器端程序:

 

01./**    
02.* @Title: ServerSocketTest.java 
03.* @Package com.test1 
04.* @Description: TODO(该文件为”Socket中,流关闭后,发生什么事“的Sever测试端) 
05.* @author 慢跑学Android 
06.* @date 2011-11-12 上午11:31:05 
07.* @version V1.0    
08.*/  
09.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)