欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java网络编程--Socket编程

程序员文章站 2023-12-29 10:02:22
...

原文:http://blog.sina.com.cn/s/blog_616e189f0100s3px.html

 

 

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 提高服务端的并发性。

上一篇:

下一篇: