Java网络编程（1） Socket缓…
2015-12-26 20:43
579 查看
转自：http://blog.sina.com.cn/s/blog_616e189f0100s3px.html
由于缓存的限制，socket先发送，再通知接收端接受，一旦发送内容（超出了发送缓存或者接收缓存（貌似超过500k就会这样)，会导致一直停留在发送的那一步，可以先让接收端打开read（）等待，发送端一遍写，接收端一边收（至少ObjectInputStream是这样）
本文由作者：大关所写，不保证内容的正确性，转载请标明出处，谢谢
Java网络编程（1）
Socket缓冲区探讨
本文主要探讨java网络套接字传输模型，并对如何将NIO应用于服务端，提高服务端的运行能力和降低服务负载。
1.1socket套接字缓冲区
Java提供了便捷的网络编程模式，尤其在套接字中，直接提供了与网络进行沟通的输入和输出流，用户对网络的操作就如同对文件操作一样简便。在客户端与服务端建立Socket连接后，客户端与服务端间的写入和写出流也同时被建立，此时即可向流中写入数据，也可以从流中读取数据。在对数据流进行操作时，很多人都会误以为，客户端和服务端的read和write应当是对应的，即：客户端调用一次写入，服务端必然调用了一次写出，而且写入和写出的字节数应当是对应的。为了解释上面的误解，我们提供了Demo-1的示例。
在Demo-1中服务端先向客户端输出了两次，之后刷新了输出缓冲区。客户端先向服务端输出了一次，然后刷新输出缓冲，之后调用了一次接收操作。从Demo-1源码以及后面提供的可能出现的结果可以看出，服务端和客户端的输入和输出并不是对应的，有时一次接收操作可以接收对方几次发过来的信息，并且不是每次输出操作对方都需要接收处理。当然了Demo-1的代码是一种错误的编写方式，没有任何一个程序员希望编写这样的代码。
篇幅限制，要看demo1请到上面链接去看
为了深入理解网络发送数据的流程，我们需要对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
Socketsocket
= 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 buffers = new ArrayList();
private Socket socket;//数据的来源
public ReadDatas(Socketsocket) throws IOException{
this.socket =socket;
}
public void read() throws IOException
{
buffers.clear();//清空上次的读取状态
InputStreamin
= socket.getInputStream();//获取输入流
int k=
0;
byte r=
0;
while(true)
{
ByteBufferbuffer
= ByteBuffer.allocate(BUFFER_SIZE);//新分配一段数据区
//如果新数据区未满，并且没有读到-1，则继续读取
for(k=
0 ; k <</span> 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 StringgetAsString()
{
StringBufferstr
= new StringBuffer();
for(ByteBufferbuffer: buffers)//遍历缓冲列表
{
str.append(new String(buffer.array(),0,buffer.limit()));//组织字符串
}
return str.toString();//返回生成的字符串
}
}
//将一条信息写出给接收端
public class WriteDatas{
public Socket socket;//数据接收端
public WriteDatas(Socketsocket,ByteBuffer[]buffers) throws IOException{
this.socket =socket;
write(buffers);
}
public WriteDatas(Socketsocket)
{
this.socket =socket;
}
public void write(ByteBuffer[]buffers) throws IOException
{
OutputStreamout
= socket.getOutputStream();//获取输出流
for(ByteBufferbuffer:buffers)
{
out.write(buffer.array());//将数据输出到缓冲区
}
out.write(new byte[]{-1});//输出终结符
out.flush();//刷新缓冲区
}
}
//服务端代码
@Test
public void server() throws IOException,InterruptedException{
ServerSocketss
= new ServerSocket(PORT);
while(true)
{
Sockets
= ss.accept();
//从网络连续读取两条信息
ReadDatasread
= new ReadDatas(s);
read.read();
System.out.println(read.getAsString());
read.read();
System.out.println(read.getAsString());
//向网络中输出一条信息
WriteDataswrite
= new WriteDatas(s);
write.write(new ByteBuffer[]{ByteBuffer.wrap("welcometo
us ! ".getBytes())});
//关闭套接字
s.close();
}
}
//客户端代码
@Test
public void client() throws UnknownHostException,IOException{
Sockets
= new Socket("localhost",PORT);//创建socket连接
//连续向服务端写入两条信息
WriteDataswrite
= new WriteDatas(s,new ByteBuffer[]{ByteBuffer.wrap("nihao
guan xin quan ! ".getBytes())});
write.write(new ByteBuffer[]{ByteBuffer.wrap("let'sstudy
java network !".getBytes())});
//从服务端读取一条信息
ReadDatasread
= new ReadDatas(s);
read.read();
System.out.println(read.getAsString());
//关闭套接字
s.close();
}
}
在Demo-3中的这种消息处理方式过于复杂，需要理解java底层的缓冲区的知识，还需要编程人员完成消息的组合（在消息末尾添加-1），在Java中可以使用一种简单的方式完成上述的操作，就是使用javaDataInputStream和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
{
ServerSocketss
= new ServerSocket(PORT);
while(true)
{
Sockets
= ss.accept();
DataInputStreamin
= new DataInputStream(s.getInputStream());
DataOutputStreamout
= new DataOutputStream(s.getOutputStream());
out.writeUTF("helloguan
xin quan ! ");
out.writeUTF("let'sstudy
java togethor! ");
System.out.println(in.readUTF());
s.close();
}
}
@Test
public void client() throws UnknownHostException,IOException
{
Sockets
= new Socket("localhost",PORT);
DataInputStreamin
= new DataInputStream(s.getInputStream());
DataOutputStreamout
= new DataOutputStream(s.getOutputStream());
System.out.println(in.readUTF());
System.out.println(in.readUTF());
out.writeUTF("welcometo
java net world ! ");
s.close();
}
}
简单总结：
上面主要介绍了javaSocket通信的缓冲区机制，并通过几个示例让您对javaSocket的工作原理有了简单了解。这里需要注意的是可读状态和可写状态，因为这两个概念将对下一节的内容理解至关重要。下一节将描述javaNIO提高服务端的并发性。
由于缓存的限制，socket先发送，再通知接收端接受，一旦发送内容（超出了发送缓存或者接收缓存（貌似超过500k就会这样)，会导致一直停留在发送的那一步，可以先让接收端打开read（）等待，发送端一遍写，接收端一边收（至少ObjectInputStream是这样）
本文由作者：大关所写，不保证内容的正确性，转载请标明出处，谢谢
Java网络编程（1）
Socket缓冲区探讨
本文主要探讨java网络套接字传输模型，并对如何将NIO应用于服务端，提高服务端的运行能力和降低服务负载。
1.1socket套接字缓冲区
Java提供了便捷的网络编程模式，尤其在套接字中，直接提供了与网络进行沟通的输入和输出流，用户对网络的操作就如同对文件操作一样简便。在客户端与服务端建立Socket连接后，客户端与服务端间的写入和写出流也同时被建立，此时即可向流中写入数据，也可以从流中读取数据。在对数据流进行操作时，很多人都会误以为，客户端和服务端的read和write应当是对应的，即：客户端调用一次写入，服务端必然调用了一次写出，而且写入和写出的字节数应当是对应的。为了解释上面的误解，我们提供了Demo-1的示例。
在Demo-1中服务端先向客户端输出了两次，之后刷新了输出缓冲区。客户端先向服务端输出了一次，然后刷新输出缓冲，之后调用了一次接收操作。从Demo-1源码以及后面提供的可能出现的结果可以看出，服务端和客户端的输入和输出并不是对应的，有时一次接收操作可以接收对方几次发过来的信息，并且不是每次输出操作对方都需要接收处理。当然了Demo-1的代码是一种错误的编写方式，没有任何一个程序员希望编写这样的代码。
篇幅限制，要看demo1请到上面链接去看
为了深入理解网络发送数据的流程，我们需要对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
Socketsocket
= 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 buffers = new ArrayList();
private Socket socket;//数据的来源
public ReadDatas(Socketsocket) throws IOException{
this.socket =socket;
}
public void read() throws IOException
{
buffers.clear();//清空上次的读取状态
InputStreamin
= socket.getInputStream();//获取输入流
int k=
0;
byte r=
0;
while(true)
{
ByteBufferbuffer
= ByteBuffer.allocate(BUFFER_SIZE);//新分配一段数据区
//如果新数据区未满，并且没有读到-1，则继续读取
for(k=
0 ; k <</span> 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 StringgetAsString()
{
StringBufferstr
= new StringBuffer();
for(ByteBufferbuffer: buffers)//遍历缓冲列表
{
str.append(new String(buffer.array(),0,buffer.limit()));//组织字符串
}
return str.toString();//返回生成的字符串
}
}
//将一条信息写出给接收端
public class WriteDatas{
public Socket socket;//数据接收端
public WriteDatas(Socketsocket,ByteBuffer[]buffers) throws IOException{
this.socket =socket;
write(buffers);
}
public WriteDatas(Socketsocket)
{
this.socket =socket;
}
public void write(ByteBuffer[]buffers) throws IOException
{
OutputStreamout
= socket.getOutputStream();//获取输出流
for(ByteBufferbuffer:buffers)
{
out.write(buffer.array());//将数据输出到缓冲区
}
out.write(new byte[]{-1});//输出终结符
out.flush();//刷新缓冲区
}
}
//服务端代码
@Test
public void server() throws IOException,InterruptedException{
ServerSocketss
= new ServerSocket(PORT);
while(true)
{
Sockets
= ss.accept();
//从网络连续读取两条信息
ReadDatasread
= new ReadDatas(s);
read.read();
System.out.println(read.getAsString());
read.read();
System.out.println(read.getAsString());
//向网络中输出一条信息
WriteDataswrite
= new WriteDatas(s);
write.write(new ByteBuffer[]{ByteBuffer.wrap("welcometo
us ! ".getBytes())});
//关闭套接字
s.close();
}
}
//客户端代码
@Test
public void client() throws UnknownHostException,IOException{
Sockets
= new Socket("localhost",PORT);//创建socket连接
//连续向服务端写入两条信息
WriteDataswrite
= new WriteDatas(s,new ByteBuffer[]{ByteBuffer.wrap("nihao
guan xin quan ! ".getBytes())});
write.write(new ByteBuffer[]{ByteBuffer.wrap("let'sstudy
java network !".getBytes())});
//从服务端读取一条信息
ReadDatasread
= new ReadDatas(s);
read.read();
System.out.println(read.getAsString());
//关闭套接字
s.close();
}
}
在Demo-3中的这种消息处理方式过于复杂，需要理解java底层的缓冲区的知识，还需要编程人员完成消息的组合（在消息末尾添加-1），在Java中可以使用一种简单的方式完成上述的操作，就是使用javaDataInputStream和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
{
ServerSocketss
= new ServerSocket(PORT);
while(true)
{
Sockets
= ss.accept();
DataInputStreamin
= new DataInputStream(s.getInputStream());
DataOutputStreamout
= new DataOutputStream(s.getOutputStream());
out.writeUTF("helloguan
xin quan ! ");
out.writeUTF("let'sstudy
java togethor! ");
System.out.println(in.readUTF());
s.close();
}
}
@Test
public void client() throws UnknownHostException,IOException
{
Sockets
= new Socket("localhost",PORT);
DataInputStreamin
= new DataInputStream(s.getInputStream());
DataOutputStreamout
= new DataOutputStream(s.getOutputStream());
System.out.println(in.readUTF());
System.out.println(in.readUTF());
out.writeUTF("welcometo
java net world ! ");
s.close();
}
}
简单总结：
上面主要介绍了javaSocket通信的缓冲区机制，并通过几个示例让您对javaSocket的工作原理有了简单了解。这里需要注意的是可读状态和可写状态，因为这两个概念将对下一节的内容理解至关重要。下一节将描述javaNIO提高服务端的并发性。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- CMake安装和使用 http://blog.sina.com.cn/s/blog_5aee9eaf0100y36u.html
- Python 网络编程 SocketServer
- cas入门：https形式发布cas证书制作
- CMake 使用方法 http://www.cnblogs.com/lyq105/archive/2010/12/03/1895067.html
- Python 网络编程 Socket
- 网络流24题 之十四 孤岛营救问题 分层图
- TCP简介
- AsyncHttpClient
- linux内核ipv4网络部分分层结构及涉入源文件
- 使用HTTP访问网络
- Caffe 抽取CNN网络特征 Python
- linux 内核网络，数据接收流程图
- 计算机网络的基本概念
- reachbility检测网络变化
- TCP三次握手
- Linux网络基本管理
- java web基础 --- 图像加载Http请求
- Volley-----网络请求框架
- 对网络基本情况进行查看方法
- URL,data(网络下载,url编码,文件读写)，NSFileManager（文件管理者，系统单例）