Java Scoket网络编程,转自commandingofficer的博客(http://blog.sina.com.cn/s/blog_616e189f0100s3px.html)
2017-03-21 13:38
573 查看
Java网络编程(1)
Socket缓冲区探讨
本文主要探讨java网络套接字传输模型,并对如何将NIO应用于服务端,提高服务端的运行能力和降低服务负载。
1.1 socket套接字缓冲区
Java提供了便捷的网络编程模式,尤其在套接字中,直接提供了与网络进行沟通的输入和输出流,用户对网络的操作就如同对文件操作一样简便。在客户端与服务端建立Socket连接后,客户端与服务端间的写入和写出流也同时被建立,此时即可向流中写入数据,也可以从流中读取数据。在对数据流进行操作时,很多人都会误以为,客户端和服务端的read和write应当是对应的,即:客户端调用一次写入,服务端必然调用了一次写出,而且写入和写出的字节数应当是对应的。为了解释上面的误解,我们提供了Demo-1的示例。
在Demo-1中服务端先向客户端输出了两次,之后刷新了输出缓冲区。客户端先向服务端输出了一次,然后刷新输出缓冲,之后调用了一次接收操作。从Demo-1源码以及后面提供的可能出现的结果可以看出,服务端和客户端的输入和输出并不是对应的,有时一次接收操作可以接收对方几次发过来的信息,并且不是每次输出操作对方都需要接收处理。当然了Demo-1的代码是一种错误的编写方式,没有任何一个程序员希望编写这样的代码。
Demo-1
}
Demo-1可能输出的结果:
结果1:
hello
结果2:
hello guanxinquan
为了深入理解网络发送数据的流程,我们需要对Socket的数据缓冲区有所了解。在创建Socket后,系统会为新创建的套接字分配缓冲区空间。这时套接字已经具有了输入缓冲区和输出缓冲区。可以通过Demo-2中的方式来获取和设置缓冲区的大小。缓冲区大小需要根据具体情况进行设置,一般要低于64K(TCP能够指定的最大负重载数据量,TCP的窗口大小是由16bit来确定的),增大缓冲区可以增大网络I/O的性能,而减少缓冲区有助于减少传入数据的backlog(就是缓冲长度,因此提高响应速度)。对于Socket和SeverSocket如果需要指定缓冲区大小,必须在连接之前完成缓冲区的设定。
Demo-2
Demo-2的输出:
8192
8192
32768
32768
了解了Socket缓冲区的概念后,需要探讨一下Socket的可写状态和可读状态。当输出缓冲区未满时,Socket是可写的(注意,不是对方启用接收操作后,本地才能可写,这是错误的理解),因此,当套接字被建立时,即处于可写如的状态。对于可读,则是指缓冲区中有接收到的数据,并且这些数据未完成处理。在socket创建时,并不处于可读状态,仅当连接的另一方向本套接字的通道写入数据后,本套接字方能处于可读状态(注意,如果对方套接字已经关闭,那么本地套接字将处于可读状态,并且每次调用read后,返回的都是-1)。
现在应用前面的讨论,重新分析一下Demo-1的执行流程,服务端与客户端建立连接后,服务器端先向缓冲区写入两条信息,在第一条信息写入时,缓冲区并未写满,因此在第二条信息输入时,第一条信息很可能还未发送,因此两条信息可能同时被传送到客户端。另一方面,如果在第二条信息写入时,第一条已经发送出去,那么客户端的接收操作仅会获得第一条信息,因为客户端没有继续接收的操作,因此第二条信息在缓冲区中,将不会被读取,当socket关闭时,缓冲区将被释放,未被读取的数据也就变的无效了。如果对方的socket已经关闭,本地再次调用读取方法,则读取方法直接返回-1,表示读到了文件的尾部。
对于缓冲区空间的设定,要根据具体情况来定,如果存在大量的长信息(比如文件传输),将缓冲区定义的大些,可能更好的利用网络资源,如果更多的是短信息(比如聊天消息),使用小的缓冲区可能更好些,这样刷新的速度会更快。一般系统默认的缓冲大小是8*1024。除非对自己处理的情况很清晰,否则请不要随意更改这个设置。
由于可读状态是在对方写入数据后或socket关闭时才能出现,因此如果客户端和服务端都停留在read时,如果没有任何一方,向对方写入数据,这将会产生一个死锁。
此外,在本地接收操作发起之前,很可能接收缓冲区中已经有数据了,这是一种异步。不要误以为,本地调用接收操作后,对方才会发送数据,实际数据何时到达,本地不能做出任何假设。
如果想要将多条输入的信息区分开,可以使用一些技巧,在文件操作中使用-1表示EOF,就是文件的结束,在网络传输中,也可以使用-1表示一条传输语句的结束。Demo-3中给出了一个读取和写入操作,在客户端和服务端对称的使用这两个类,可以将每一条信息分析出来。Demo-3中并不是将网络的传输同步,而是分析出缓冲中的数据,将以-1为结尾进行数据划分。如果写聊天程序可以使用类似的模式。
Demo-3
Demo-4
简单总结:
上面主要介绍了java Socket通信的缓冲区机制,并通过几个示例让您对java Socket的工作原理有了简单了解。这里需要注意的是可读状态和可写状态,因为这两个概念将对下一节的内容理解至关重要。下一节将描述java NIO提高服务端的并发性。
Socket缓冲区探讨
本文主要探讨java网络套接字传输模型,并对如何将NIO应用于服务端,提高服务端的运行能力和降低服务负载。
1.1 socket套接字缓冲区
Java提供了便捷的网络编程模式,尤其在套接字中,直接提供了与网络进行沟通的输入和输出流,用户对网络的操作就如同对文件操作一样简便。在客户端与服务端建立Socket连接后,客户端与服务端间的写入和写出流也同时被建立,此时即可向流中写入数据,也可以从流中读取数据。在对数据流进行操作时,很多人都会误以为,客户端和服务端的read和write应当是对应的,即:客户端调用一次写入,服务端必然调用了一次写出,而且写入和写出的字节数应当是对应的。为了解释上面的误解,我们提供了Demo-1的示例。
在Demo-1中服务端先向客户端输出了两次,之后刷新了输出缓冲区。客户端先向服务端输出了一次,然后刷新输出缓冲,之后调用了一次接收操作。从Demo-1源码以及后面提供的可能出现的结果可以看出,服务端和客户端的输入和输出并不是对应的,有时一次接收操作可以接收对方几次发过来的信息,并且不是每次输出操作对方都需要接收处理。当然了Demo-1的代码是一种错误的编写方式,没有任何一个程序员希望编写这样的代码。
Demo-1
package com.upc.upcgrid.guan.chapter02; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.net.UnknownHostException; import org.junit.Test; public class SocketWriteTest { public static final int PORT = 12123; public static final int BUFFER_SIZE = 1024; //服务端代码 @Test public void server() throws IOException, InterruptedException{ ServerSocket ss = new ServerSocket(PORT); while(true) { Socket s = ss.accept(); //这里向网络进行两次写入 s.getOutputStream().write("hello ".getBytes()); s.getOutputStream().write("guanxinquan ".getBytes()); s.getOutputStream().flush(); s.close(); } }
//客户端代码 @Test public void client() throws UnknownHostException, IOException{ byte[] buffer; Socket s = new Socket("localhost",PORT);//创建socket连接 s.getOutputStream().write(new byte[BUFFER_SIZE]); s.getOutputStream().flush(); int i = s.getInputStream().read(buffer = new byte[BUFFER_SIZE]); System.out.println(new String(buffer,0,i)); }
}
Demo-1可能输出的结果:
结果1:
hello
结果2:
hello guanxinquan
为了深入理解网络发送数据的流程,我们需要对Socket的数据缓冲区有所了解。在创建Socket后,系统会为新创建的套接字分配缓冲区空间。这时套接字已经具有了输入缓冲区和输出缓冲区。可以通过Demo-2中的方式来获取和设置缓冲区的大小。缓冲区大小需要根据具体情况进行设置,一般要低于64K(TCP能够指定的最大负重载数据量,TCP的窗口大小是由16bit来确定的),增大缓冲区可以增大网络I/O的性能,而减少缓冲区有助于减少传入数据的backlog(就是缓冲长度,因此提高响应速度)。对于Socket和SeverSocket如果需要指定缓冲区大小,必须在连接之前完成缓冲区的设定。
Demo-2
package com.upc.upcgrid.guan.chapter02; import java.net.Socket; import java.net.SocketException; public class SocketBufferTest { public static void main(String[] args) throws SocketException { //创建一个socket Socket socket = new Socket(); //输出缓冲区大小 System.out.println(socket.getSendBufferSize()); System.out.println(socket.getReceiveBufferSize()); //重置缓冲区大小 socket.setSendBufferSize(1024*32); socket.setReceiveBufferSize(1024*32); //再次输出缓冲区大小 System.out.println(socket.getSendBufferSize()); System.out.println(socket.getReceiveBufferSize()); } }
Demo-2的输出:
8192
8192
32768
32768
了解了Socket缓冲区的概念后,需要探讨一下Socket的可写状态和可读状态。当输出缓冲区未满时,Socket是可写的(注意,不是对方启用接收操作后,本地才能可写,这是错误的理解),因此,当套接字被建立时,即处于可写如的状态。对于可读,则是指缓冲区中有接收到的数据,并且这些数据未完成处理。在socket创建时,并不处于可读状态,仅当连接的另一方向本套接字的通道写入数据后,本套接字方能处于可读状态(注意,如果对方套接字已经关闭,那么本地套接字将处于可读状态,并且每次调用read后,返回的都是-1)。
现在应用前面的讨论,重新分析一下Demo-1的执行流程,服务端与客户端建立连接后,服务器端先向缓冲区写入两条信息,在第一条信息写入时,缓冲区并未写满,因此在第二条信息输入时,第一条信息很可能还未发送,因此两条信息可能同时被传送到客户端。另一方面,如果在第二条信息写入时,第一条已经发送出去,那么客户端的接收操作仅会获得第一条信息,因为客户端没有继续接收的操作,因此第二条信息在缓冲区中,将不会被读取,当socket关闭时,缓冲区将被释放,未被读取的数据也就变的无效了。如果对方的socket已经关闭,本地再次调用读取方法,则读取方法直接返回-1,表示读到了文件的尾部。
对于缓冲区空间的设定,要根据具体情况来定,如果存在大量的长信息(比如文件传输),将缓冲区定义的大些,可能更好的利用网络资源,如果更多的是短信息(比如聊天消息),使用小的缓冲区可能更好些,这样刷新的速度会更快。一般系统默认的缓冲大小是8*1024。除非对自己处理的情况很清晰,否则请不要随意更改这个设置。
由于可读状态是在对方写入数据后或socket关闭时才能出现,因此如果客户端和服务端都停留在read时,如果没有任何一方,向对方写入数据,这将会产生一个死锁。
此外,在本地接收操作发起之前,很可能接收缓冲区中已经有数据了,这是一种异步。不要误以为,本地调用接收操作后,对方才会发送数据,实际数据何时到达,本地不能做出任何假设。
如果想要将多条输入的信息区分开,可以使用一些技巧,在文件操作中使用-1表示EOF,就是文件的结束,在网络传输中,也可以使用-1表示一条传输语句的结束。Demo-3中给出了一个读取和写入操作,在客户端和服务端对称的使用这两个类,可以将每一条信息分析出来。Demo-3中并不是将网络的传输同步,而是分析出缓冲中的数据,将以-1为结尾进行数据划分。如果写聊天程序可以使用类似的模式。
Demo-3
package com.upc.upcgrid.guan.chapter02; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; import java.net.UnknownHostException; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.List; import org.junit.Test; public class SocketWriteTest { public static final int PORT = 12123; public static final int BUFFER_SIZE = 1024; //读取一条传入的,以-1为结尾的数据 public class ReadDatas{ //数据临时缓冲用 private List<ByteBuffer> buffers = new ArrayList<ByteBuffer>(); private Socket socket;//数据的来源 public ReadDatas(Socket socket) throws IOException { this.socket = socket; } public void read() throws IOException { buffers.clear();//清空上次的读取状态 InputStream in = socket.getInputStream();//获取输入流 int k = 0; byte r = 0; while(true) { ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);//新分配一段数据区 //如果新数据区未满,并且没有读到-1,则继续读取 for(k = 0 ; k < BUFFER_SIZE ; k++) { r = (byte) in.read();//读取一个数据 if(r != -1)//数据不为-1,简单放入缓冲区 buffer.put(r); else{//读取了一个-1,表示这条信息结束 buffer.flip();//翻转缓冲,以备读取操作 buffers.add(buffer);//将当前的buffer添加到缓冲列表 return; } } buffers.add(buffer);//由于缓冲不足,直接将填满的缓冲放入缓冲列表 } } public String getAsString() { StringBuffer str = new StringBuffer(); for(ByteBuffer buffer: buffers)//遍历缓冲列表 { str.append(new String(buffer.array(),0,buffer.limit()));//组织字符串 } return str.toString();//返回生成的字符串 } } //将一条信息写出给接收端 public class WriteDatas{ public Socket socket;//数据接收端 public WriteDatas(Socket socket,ByteBuffer[] buffers) throws IOException { this.socket = socket; write(buffers); } public WriteDatas(Socket socket) { this.socket = socket; } public void write(ByteBuffer[] buffers) throws IOException { OutputStream out = socket.getOutputStream();//获取输出流 for(ByteBuffer buffer:buffers) { out.write(buffer.array());//将数据输出到缓冲区 } out.write(new byte[]{-1});//输出终结符 out.flush();//刷新缓冲区 } } //服务端代码 @Test public void server() throws IOException, InterruptedException{ ServerSocket ss = new ServerSocket(PORT); while(true) { Socket s = ss.accept(); //从网络连续读取两条信息 ReadDatas read = new ReadDatas(s); read.read(); System.out.println(read.getAsString()); read.read(); System.out.println(read.getAsString()); //向网络中输出一条信息 WriteDatas write = new WriteDatas(s); write.write(new ByteBuffer[]{ByteBuffer.wrap("welcome to us ! ".getBytes())}); //关闭套接字 s.close(); } } //客户端代码 @Test public void client() throws UnknownHostException, IOException{ Socket s = new Socket("localhost",PORT);//创建socket连接 //连续向服务端写入两条信息 WriteDatas write = new WriteDatas(s,new ByteBuffer[]{ByteBuffer.wrap("ni hao guan xin quan ! ".getBytes())} ); write.write(new ByteBuffer[]{ByteBuffer.wrap("let's study java network !".getBytes())}); //从服务端读取一条信息 ReadDatas read = new ReadDatas(s); read.read(); System.out.println(read.getAsString()); //关闭套接字 s.close(); } }
在Demo-3中的这种消息处理方式过于复杂,需要理解java底层的缓冲区的知识,还需要编程人员完成消息的组合(在消息末尾添加-1),在Java中可以使用一种简单的方式完成上述的操作,就是使用java DataInputStream和DataOutputStream提供的方法。Demo-4给出了使用java相关流类完成同步的消息的方法(估计他们与我们Demo-3使用的方式是相似的)。你可以查阅java其它API,可以找到其他的方式。
Demo-4
package com.upc.upcgrid.guan.chapter02; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.net.UnknownHostException; import org.junit.Test; public class SocketDataStream { public static final int PORT = 12123; @Test public void server() throws IOException { ServerSocket ss = new ServerSocket(PORT); while(true) { Socket s = ss.accept(); DataInputStream in = new DataInputStream(s.getInputStream()); DataOutputStream out = new DataOutputStream(s.getOutputStream()); out.writeUTF("hello guan xin quan ! "); out.writeUTF("let's study java togethor! "); System.out.println(in.readUTF()); s.close(); } } @Test public void client() throws UnknownHostException, IOException { Socket s = new Socket("localhost",PORT); DataInputStream in = new DataInputStream(s.getInputStream()); DataOutputStream out = new DataOutputStream(s.getOutputStream()); System.out.println(in.readUTF()); System.out.println(in.readUTF()); out.writeUTF("welcome to java net world ! "); s.close(); } }
简单总结:
上面主要介绍了java Socket通信的缓冲区机制,并通过几个示例让您对java Socket的工作原理有了简单了解。这里需要注意的是可读状态和可写状态,因为这两个概念将对下一节的内容理解至关重要。下一节将描述java NIO提高服务端的并发性。
相关文章推荐
- Java的基本I/O(输入/输出)系统copy from (http://blog.sina.com.cn/s/blog_5ec67df20100d6ao.html)
- 求两个数组的交集、并集和差集算法分析与实现(转自http://blog.sina.com.cn/s/blog_616e189f0100mrdn.html)
- WinInet中的几个网络函数(原作者博客 http://blog.sina.com.cn/s/blog_5f85e9270100t00g.html)
- JAVA学习方向(原文:http://blog.sina.com.cn/s/blog_9671d5180101lj4q.html)
- 转于博客http://blog.sina.com.cn/zilingerenen,java的断言
- java学习笔记------ PrintStream_都市游侠_新浪博客 http://blog.sina.com.cn/s/blog_6c1fe98c01012lcu.html
- Java的基本I/O(输入/输出)系统copy from (http://blog.sina.com.cn/s/blog_5ec67df20100d6ao.html)
- 刘楚国常用的博客是:http://blog.sina.com.cn/liuchuguo
- sina博客 http://blog.sina.com.cn/javason
- http://blog.sina.com.cn/s/articlelist_1587621077_0_1.html
- 键盘扫描码(转)(转自:http://blog.sina.com.cn/s/blog_4d75136a0100doxp.html)
- http://blog.sina.com.cn/jsmedia 郎咸平 博客
- 抽象类与接口的区别--http://blog.sina.com.cn/s/blog_5e9f4ac60100ddfq.html
- 欢迎访问我的sina博客!谢谢!http://blog.sina.com.cn/m/hanian
- 用FileZilla Server开FTP:看图入门(转自:http://blog.sina.com.cn/s/blog_46dac66f010003cm.html)
- Java 回调函数 转自:http://blog.sina.com.cn/s/blog_48cf38890100go6x.html
- LoadXML的正确使用(原文:http://blog.sina.com.cn/s/blog_68530d690100mlcp.html)
- 再转帖个OpenLayers 入门级(来自http://blog.sina.com.cn/s/blog_3dbf03df01008uu3.html)
- 再转帖个OpenLayers 入门级(来自http://blog.sina.com.cn/s/blog_3dbf03df01008uu3.html)
- 用Eclipse CDT 配置C/C++ 编译环境(转自http://blog.sina.com.cn/s/blog_45dbe005010009jf.html)