http://blog.csdn.net/dabing69221/article/details/17351881
前言:
在Java Socket中提供了2中关闭方法,其中包括:close() 、shutdownOutput()/shutdownInput() ,前一段时间做项目中用到了Socket,但是没有好好总结。
现在,我把我遇到的问题分享一下:
在网络协议中,通常明确指定了由谁来发起 “关闭”连接。
例如:在HTTP协议中,客户端先向服务端发送一个请求,然后服务器响应请求的信息。由于客户端不知道服务端响应信息的大小,因此服务器必须通过关闭套
接字来指示响应信息结束 —— 这个就是由服务器端发起的关闭连接!
一. Socket.close()方法
这个方法我们估计都不会陌生,一般使用完Socket后,都会调用Socket.close() 来释放相关的资源。当我们调用Socket.close()方法将同时终止两个方向(输入
和输出)的数据流。一旦一个终端(客户端或服务端)关闭了套接字,它将无法再发送或接收数据。这就意味着close( )方法只能在调用者完成了通信之后用来
给另一端发送信号。只要服务端收到了客户端的关闭信号,就立即关闭连接。
1. 考虑一个场景:
假设你有一个服务器,接收到消息后,在发回给客户端,这种情况下应该是有哪一端来关闭连接呢?
由于从客户端发送的消息长度是任意的,客户端需要关闭连接以通知服务器消息发送完毕,那么客户端应该什么时候调用close( )方法呢,如果客户端在发送完最后
一个字节后立即调用close( )方法,它将无法接收服务器发送的消息 (因为: 关闭此套接字也将会关闭该套接字的InputStream
和OutputStream
);如果客户端在接收
完所有的数据后在调用close ( )方法,那么服务端 将不知道到底有多少数据要接收(因为:客户端的输出流一直没有关闭,所以,服务端的输入流也就无法到达流末尾返回-1),
所以,服务器在接收数据时就一直阻塞,而这个时候客户端又要等待接收服务端发送来的消息(即使服务端发送了消息,但因为服务端的输出流一直没有关闭,所以,
服务端的输入流也就无法到达流末尾返回-1,所以客户端在接收数据时就一直阻塞) —— 以上问题就造成:”服务端和客户端都在接收数据时阻塞"
情况一 :客户端在发送完最后一个字节后立即调用close( )方法
- //服务端
- publicclassServer
- {
- publicstaticvoidmain(String[]args)throwsIOException
- {
- System.out.println("------------------------------------");
- System.out.println("Serverstart......");
- System.out.println("------------------------------------");
- ServerSocketserver=newServerSocket(8888);
- while(true)
- {
- Socketclient=server.accept();
- OutputStreamout=client.getOutputStream();
- InputStreamin=client.getInputStream();
- ByteArrayOutputStreambyteArrayOut=newByteArrayOutputStream();
- byte[]temp=newbyte[1024];
- intrealLen=0;
- while((realLen=in.read(temp))!=-1)
- {
- byteArrayOut.write(temp,0,realLen);
- }
- byte[]recv=byteArrayOut.toByteArray();
- //将接收的消息,发回给客户端
- out.write(recv);
- out.flush();
- }
- }
- }
- //客户端
- publicclassClient
- {
- publicstaticvoidmain(String[]args)throwsIOException
- {
- System.out.println("------------------------------------");
- System.out.println("Clientstart......");
- System.out.println("------------------------------------");
- byte[]msg=newString("connectsuccessfully!!!").getBytes();
- InetAddressinetAddr=InetAddress.getLocalHost();
- Socketclient=newSocket(inetAddr,8888);
- OutputStreamout=client.getOutputStream();
- InputStreamin=client.getInputStream();
- out.write(msg);
- out.flush();
- //情况一:客户端在发送完最后一个字节后立即调用close()方法
- client.close();
- ByteArrayOutputStreambyteArrayOut=newByteArrayOutputStream();
- byte[]temp=newbyte[1024];
- intrealLen=0;
- while((realLen=in.read(temp))!=-1)
- {
- byteArrayOut.write(temp,0,realLen);
- }
- byte[]recv=byteArrayOut.toByteArray();
- System.out.println("Clientreceivemsg:"+newString(recv));
- /*
- *切记:在这里关闭输入流,并不会使服务端的输入流到达流末尾返回-1,仅仅是释放资源而已
- */
- in.close();
- out.close();
- }
- }
运行结果:服务端与客户端都接收不到数据
情况二:如果客户端在接收完所有的数据后在调用close ( )方法
服务端代码没变*(请参看情况一,所以这里只贴出客户端代码:
- //客户端
- publicclassClient
- {
- publicstaticvoidmain(String[]args)throwsIOException
- {
- System.out.println("------------------------------------");
- System.out.println("Clientstart......");
- System.out.println("------------------------------------");
- byte[]msg=newString("connectsuccessfully!!!").getBytes();
- InetAddressinetAddr=InetAddress.getLocalHost();
- Socketclient=newSocket(inetAddr,8888);
- OutputStreamout=client.getOutputStream();
- InputStreamin=client.getInputStream();
- out.write(msg);
- out.flush();
- ByteArrayOutputStreambyteArrayOut=newByteArrayOutputStream();
- byte[]temp=newbyte[1024];
- intrealLen=0;
- while((realLen=in.read(temp))!=-1)
- {
- byteArrayOut.write(temp,0,realLen);
- }
- //情况二:如果客户端在接收完所有的数据后在调用close()方法
- client.close();
- byte[]recv=byteArrayOut.toByteArray();
- System.out.println("Clientreceivemsg:"+newString(recv));
- /*
- *切记:在这里关闭输入流,并不会使服务端的输入流到达流末尾返回-1,仅仅是释放资源而已
- */
- in.close();
- out.close();
- }
- }
(如果将客户端代码的23-26行代码注释掉,双方通信就会完成。这里的原因并不是代码注释中所写的,而是因为死锁了。关闭socket肯定会在通信流中有结束信息。客户端发送过消息之后,就开始堵塞接收服务器返回的消息,而服务器在21行,第一次执行read(temp)获得了字节数组,循环第二次时又开始堵塞read(temp),也就是在等待客户端发送的结束消息,于是就死锁了)
运行结果:服务端与客户端都接收不到数据
二. Sockt.shutdownInput( )与Socket.shutdownOutput( )
在上边的例子中,我们考虑了一个场景,但是分析之后——发现会造成 “服务端和客户端都在接收数据时阻塞 ”,我们现在需要一种方法来告诉连接的另一端
“我已经发送完所有数据” ,同时还要保持接收数据的能力。
这个问题Java中已经帮我们解决了,TCP套接字中提供了一种实现这个功能的方法,Socket.shutdownOutput( )和Socket.shutdownInput( )方法能够将输入输出流相互独立的关闭。
调用Socket.shutdownInput( )后, 禁用此套接字的输入流,发送到套接字的输入流端的任何数据都将被确认然后被静默丢弃。任何想从该套接字的输入流读取数据的操作都将返回-1;
调用Socket.shutdownOutput()后,禁用此套接字的输出流,对于 TCP 套接字,任何以前写入的数据都将被发送,并且后跟 TCP 的正常连接终止序列(即-1),之后,从另一端TCP
套接字的输入流中读取数据时,如果到达输入流末尾而不再有数据可用,则返回-1
。
注意:
当调用Socket.shutdownInput( )后,还能够往该套接字中写数据(执行OutputStream.write( ));
当调用Socket.shutdownOutput( )后,还能够往该套接字中读数据(执行InputStream.read( ));
使用Socket.shutdownInput( )和Socket.shutdownOutput( ),代码如下:
- //服务端
- publicclassServer
- {
- publicstaticvoidmain(String[]args)throwsIOException
- {
- System.out.println("------------------------------------");
- System.out.println("Serverstart......");
- System.out.println("------------------------------------");
- ServerSocketserver=newServerSocket(8888);
- while(true)
- {
- Socketclient=server.accept();
- OutputStreamout=client.getOutputStream();
- InputStreamin=client.getInputStream();
- ByteArrayOutputStreambyteArrayOut=newByteArrayOutputStream();
- byte[]temp=newbyte[1024];
- intrealLen=0;
- while((realLen=in.read(temp))!=-1)
- {
- byteArrayOut.write(temp,0,realLen);
- }
- byte[]recv=byteArrayOut.toByteArray();
- //将接收的消息,发回给客户端
- out.write(recv);
- out.flush();
- //关闭该套接字的输入流
- client.shutdownOutput();
- }
- }
- }
- //客户端
- publicclassClient
- {
- publicstaticvoidmain(String[]args)throwsIOException
- {
- System.out.println("------------------------------------");
- System.out.println("Clientstart......");
- System.out.println("------------------------------------");
- byte[]msg=newString("connectsuccessfully!!!").getBytes();
- InetAddressinetAddr=InetAddress.getLocalHost();
- Socketclient=newSocket(inetAddr,8888);
- OutputStreamout=client.getOutputStream();
- InputStreamin=client.getInputStream();
- out.write(msg);
- out.flush();
- //关闭该套接字的输出流
- client.shutdownOutput();
- ByteArrayOutputStreambyteArrayOut=newByteArrayOutputStream();
- byte[]temp=newbyte[1024];
- intrealLen=0;
- while((realLen=in.read(temp))!=-1)
- {
- byteArrayOut.write(temp,0,realLen);
- }
- byte[]recv=byteArrayOut.toByteArray();
- System.out.println("Clientreceivemsg:"+newString(recv));
- /*
- *切记:在这里关闭输入流,并不会使服务端的输入流到达流末尾返回-1,仅仅是释放资源而已
- */
- in.close();
- out.close();
- }
- }
运行看看,完全没有问题,网上还有人说 “Socket.shutdownInput( )与Socket.shutdownOutput( )” 是 “半关闭方法” — 其实这么说也对。
三. 深入剖析TCP关闭连接机制
TCP套接字中有一个优雅的关闭机制,以保证应用程序在关闭连接时不必担心正在传输的数据会丢失。这个机制还允许两个方向的数据传输相互独立的终止。
关闭机制的工作流程:应用程序通过调用连接套接字的close( )方法或shutdownOutput( )方法表明数据已经发送完毕。此刻,底层的TCP实现首先将留存在
SendQ队列中的数据传输出去(还要依赖另一端RecvQ队列的剩余空间),然后向另一端发送一个关闭TCP连接的握手消息,该关闭握手消息可以看作时流
终止标志:它告诉接收端TCP不会再有新的数据传入RecvQ队列了。(关闭握手消息本身并没有传递给接收端应用程序,而是通过read( ) 方法返回-1来指示
其在字节流中的位置)正在关闭的TCP将等待其关闭握手消息的确认信息,该确认信息表明在连接上传输的所有数据已经安全的传输到了RecvQ中。只要接收
到了确认信息,该连接就变成 “半关闭 ”状态。直到连接的另一个方向上收到了对称的握手消息后,连接才完全关闭——也就是说,连接的两端都表明它们再也
没有数据要发送了。
不管是客户端还是服务端在接收另一方发来的消息时,肯定有一种机制来保证接收到了消息的末尾
上例中,如果不用shutdown,要自定义一些协议保证接收,比如刚开始的第一个字节表示接下来传输的长度,接收方只需接收到这个长度大小的消息就不用再接收了
上例中直接用的InputStream,在java中已经有封装好的类,就是DataInputStream, 在接收的时候就是先读取长度,再按照长度读取流,需要主要的发送方要用DataOutputStream发送
如果用BufferedReader和PrintWriter来接收和发送数据时,一般接收用readline,那么发送一定是println,而不是print,应该readline一定要读到一个行换行才返回,否则就是堵塞了
server
package communication;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
//服务端
public class Server
{
public static void main(String[] args) throws IOException
{
System.out.println("------------------------------------");
System.out.println("Server start......");
System.out.println("------------------------------------");
ServerSocket server = new ServerSocket(8889);
while (true)
{
// Socket client = server.accept();
// OutputStream out = client.getOutputStream();
// InputStream in = client.getInputStream();
//
// ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();
// byte[] temp = new byte[1024];
// int realLen = 0;
// while ((realLen = in.read(temp)) != -1)
// {
// System.out.println("read");
// byteArrayOut.write(temp, 0, realLen);
// }
//
// byte[] recv = byteArrayOut.toByteArray();
//
// // 将接收的消息,发回给客户端
// out.write(recv);
// out.flush();
Socket client = server.accept();
System.out.println("accept");
OutputStream out = client.getOutputStream();
InputStream in = client.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String line = br.readLine();
System.out.println(line);//不能是print
PrintWriter pw = new PrintWriter(out);
pw.println("server " + line);
pw.flush();
br.close();
pw.close();
}
}
}
client
package communication;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
//客户端
public class ToyClient
{
public static void main(String[] args) throws IOException
{
System.out.println("------------------------------------");
System.out.println("Client start......");
System.out.println("------------------------------------");
// byte[] msg = new String("connect successfully!!!").getBytes();
//
// InetAddress inetAddr = InetAddress.getLocalHost();
// Socket client = new Socket(inetAddr, 8888);
// OutputStream out = client.getOutputStream();
// InputStream in = client.getInputStream();
//
// out.write(msg);
// out.flush();
//
// ByteArrayOutputStream byteArrayOut = new ByteArrayOutputStream();
// byte[] temp = new byte[1024];
// int realLen = 0;
// while ((realLen = in.read(temp)) != -1)
// {
// byteArrayOut.write(temp, 0, realLen);
// }
// // 情况二 :如果客户端在接收完所有的数据后在调用close()方法
//
// in.close();
// out.close();
//
// client.close();
//
// byte[] recv = byteArrayOut.toByteArray();
//
// System.out.println("Client receive msg:" + new String(recv));
/*
* 切记:在这里关闭输入流,并不会使服务端的输入流到达流末尾返回-1,仅仅是释放资源而已
*/
InetAddress inetAddr = InetAddress.getLocalHost();
Socket client = new Socket(inetAddr, 8889);
OutputStream out = client.getOutputStream();
InputStream in = client.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
PrintWriter pw = new PrintWriter(out);
pw.println("connect successfully!!!");//bu
pw.flush();
//String line = br.readLine();
//System.out.println(line);
pw.close();
br.close();
client.close();
}
}