Shulou(Shulou.com)06/03 Report--

This article mainly explains "what are the solutions to the Socket sticky package problem?" the content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn what are the solutions to the Socket sticky package problem.

What is the TCP protocol?

The full name of TCP is Transmission Control Protocol (Transmission Control Protocol), which is defined by IETF's RFC 793. it is a connection-oriented point-to-point transport layer communication protocol.

TCP provides information from the sending node about the delivery of packets transmitted to the target node by using sequence numbers and acknowledgement messages. TCP ensures the reliability of data, end-to-end delivery, reordering and retransmission until a timeout condition is reached or an acknowledgment of the packet is received.

TCP is the most commonly used protocol on Internet, and it is also the basis for HTTP (HTTP 1.0/HTTP 2.0) communication. When we request a web page in the browser, the computer will send the TCP packet to the address of the Web server and ask it to return the web page to us. The Web server responds by sending the TCP packet stream, and then the browser sews these packets together to form a web page.

The whole point of TCP is its reliability, it sorts packets by numbering them, and it checks for errors by having the server send the response back to the browser saying "received", so no data is lost or corrupted during transmission.

At present, the version of the mainstream HTTP protocol in the market is HTTP/1.1, as shown in the following figure:

What is the sticky bag and half package problem?

The sticky packet problem means that when you send two messages, such as ABC and DEF, but the other end receives ABCD, it is called sticky packet when you read two pieces of data at once (normally it should be read one by one).

The semi-packet problem means that when the message sent is ABC, the other end receives two messages: AB and C. in this case, it is called semi-packet.

Why is there a sticky bag and a half bag problem?

This is because TCP is a connection-oriented transport protocol, the data transmitted by TCP is in the form of a stream, and the stream data does not have a clear start-end boundary, so TCP has no way to determine which stream belongs to a message.

The main reasons for sticking bags are:

Each time the sender writes data

< 套接字(Socket)缓冲区大小; 接收方读取套接字(Socket)缓冲区数据不够及时。 半包的主要原因： 发送方每次写入数据 >

Socket (Socket) buffer size

The data sent is larger than the MTU (Maximum Transmission Unit, maximum transmission unit) of the protocol, so it must be unpacked.

Small knowledge: what is a buffer zone?

A buffer, also known as a cache, is part of the memory space. In other words, a certain amount of storage space is reserved in the memory space, which is used to buffer the input or output data, and this part of the reserved space is called buffer.

The advantages of buffers take the writing of file streams as an example. If we do not use buffers, then each write operation CPU will interact with the low-speed storage device, that is, the disk, so the whole speed of writing to the file will be limited by the low-speed storage device (disk). However, if a buffer is used, each write operation will first save the data in the high-speed buffer memory, and when the buffer data reaches a certain threshold, the file will be written to disk at one time. Because the write speed of memory is much faster than that of disk, when there is a buffer, the write speed of files is greatly improved.

Demonstration of sticky package and half-package problem

Next, let's use code to demonstrate the sticky package and half-package problem. To make the demonstration intuitive, I'll set up two roles:

The server is used to receive messages

The client sends a fixed message.

Then observe the sticky packet and half-packet problem by printing the information received by the server.

The server-side code is as follows:

/ * Server side (only responsible for receiving messages) * / class ServSocket {/ / length of byte array private static final int BYTE_LENGTH = 20; public static void main (String [] args) throws IOException {/ / create Socket server ServerSocket serverSocket = new ServerSocket (9999); / / get client connection Socket clientSocket = serverSocket.accept () / / get the stream object try (InputStream inputStream = clientSocket.getInputStream ()) {while (true) {/ / get the information sent by the client byte [] bytes = new byte [byte _ LENGTH] / / read the message sent by the client int count = inputStream.read (bytes, 0, BYTE_LENGTH); if (count > 0) {/ / successfully received the valid message and printed the System.out.println ("the message received from the client is:" + new String (bytes)) } count = 0;}

The client code is as follows:

/ * client (only responsible for sending messages) * / static class ClientSocket {public static void main (String [] args) throws IOException {/ / create a Socket client and try to connect to the server Socket socket = new Socket ("127.0.0.1", 9999); / / the content of the message sent final String message = "Hi,Java." / / use the output stream to send the message try (OutputStream outputStream = socket.getOutputStream ()) {/ / send the message for (int I = 0; I) to the server 10 times

< 10; i++) { // 发送消息 outputStream.write(message.getBytes()); } } } } 以上程序的通讯结果如下图所示： 通过上述结果我们可以看出，服务器端发生了粘包和半包的问题，因为客户端发送了 10 次固定的"Hi,Java."的消息，正常的结果应该是服务器端也接收到了 10 次固定的消息才对，但现实的结果并非如此。 粘包和半包的解决方案 粘包和半包的解决方案有以下 3 种： 鸿蒙官方战略合作共建--HarmonyOS技术社区 发送方和接收方规定固定大小的缓冲区，也就是发送和接收都使用固定大小的 byte[] 数组长度，当字符长度不够时使用空字符弥补; 在 TCP 协议的基础上封装一层数据请求协议，既将数据包封装成数据头(存储数据正文大小)+ 数据正文的形式，这样在服务端就可以知道每个数据包的具体长度了，知道了发送数据的具体边界之后，就可以解决半包和粘包的问题了; 以特殊的字符结尾，比如以"\n"结尾，这样我们就知道结束字符，从而避免了半包和粘包问题(推荐解决方案)。 那么接下来我们就来演示一下，以上解决方案的具体代码实现。 解决方案1：固定缓冲区大小 固定缓冲区大小的实现方案，只需要控制服务器端和客户端发送和接收字节的(数组)长度相同即可。 服务器端实现代码如下： /** * 服务器端，改进版本一（只负责接收消息） */ static class ServSocketV1 { private static final int BYTE_LENGTH = 1024; // 字节数组长度（收消息用） public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(9091); // 获取到连接 Socket clientSocket = serverSocket.accept(); try (InputStream inputStream = clientSocket.getInputStream()) { while (true) { byte[] bytes = new byte[BYTE_LENGTH]; // 读取客户端发送的信息 int count = inputStream.read(bytes, 0, BYTE_LENGTH); if (count >

0) {/ / received message print System.out.println ("the message received from the client is:" + new String (bytes) .trim ());} count = 0;}

The client implementation code is as follows:

/ * client, improved version 1 (only responsible for receiving messages) * / static class ClientSocketV1 {private static final int BYTE_LENGTH = 1024; / / byte length public static void main (String [] args) throws IOException {Socket socket = new Socket ("127.0.0.1", 9091); final String message = "Hi,Java." / / send message try (OutputStream outputStream = socket.getOutputStream ()) {/ / assemble the data into a fixed-length byte array byte [] bytes = new byte [byte _ LENGTH]; int idx = 0; for (byte b: message.getBytes ()) {bytes [idx] = b; idx++ } / / send the message for (int I = 0; I) to the server 10 times

< 10; i++) { outputStream.write(bytes, 0, BYTE_LENGTH); } } } } 以上代码的执行结果如下图所示： 优缺点分析 从以上代码可以看出，虽然这种方式可以解决粘包和半包的问题，但这种固定缓冲区大小的方式增加了不必要的数据传输，因为这种方式当发送的数据比较小时会使用空字符来弥补，所以这种方式就大大的增加了网络传输的负担，所以它也不是最佳的解决方案。 解决方案二：封装请求协议 这种解决方案的实现思路是将请求的数据封装为两部分：数据头+数据正文，在数据头中存储数据正文的大小，当读取的数据小于数据头中的大小时，继续读取数据，直到读取的数据长度等于数据头中的长度时才停止。 因为这种方式可以拿到数据的边界，所以也不会导致粘包和半包的问题，但这种实现方式的编码成本较大也不够优雅，因此不是最佳的实现方案，因此我们这里就略过，直接来看最终的解决方案吧。 解决方案三：特殊字符结尾，按行读取 以特殊字符结尾就可以知道流的边界了，因此也可以用来解决粘包和半包的问题，此实现方案是我们推荐最终解决方案。 这种解决方案的核心是，使用 Java 中自带的 BufferedReader 和 BufferedWriter，也就是带缓冲区的输入字符流和输出字符流，通过写入的时候加上 \n 来结尾，读取的时候使用 readLine 按行来读取数据，这样就知道流的边界了，从而解决了粘包和半包的问题。 服务器端实现代码如下： /** * 服务器端，改进版三(只负责收消息) */ static class ServSocketV3 { public static void main(String[] args) throws IOException { // 创建 Socket 服务器端 ServerSocket serverSocket = new ServerSocket(9092); // 获取客户端连接 Socket clientSocket = serverSocket.accept(); // 使用线程池处理更多的客户端 ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100, TimeUnit.SECONDS, new LinkedBlockingQueue(1000)); threadPool.submit(() ->

{/ / message processing processMessage (clientSocket);}) } / * message processing * @ param clientSocket * / private static void processMessage (Socket clientSocket) {/ / get the message flow object try sent by the client (BufferedReader bufferedReader = new BufferedReader (new InputStreamReader (clientSocket.getInputStream () {while (true) {/ / read the message sent by the client by line String msg = bufferedReader.readLine () If (msg! = null) {/ / successfully received the message from the client and printed System.out.println ("received message from the client:" + msg);} catch (IOException ioException) {ioException.printStackTrace ();}

PS: the above code uses thread pooling to solve the problem of multiple clients accessing the server at the same time, thus achieving an one-to-many server response.

The implementation code of the client is as follows:

/ * client, improved version 3 (only responsible for sending messages) * / static class ClientSocketV3 {public static void main (String [] args) throws IOException {/ / launch Socket and try to connect to the server Socket socket = new Socket ("127.0.0.1", 9092); final String message = "Hi,Java." / / send message try (BufferedWriter bufferedWriter = new BufferedWriter (new OutputStreamWriter (socket.getOutputStream () {/ / send message for (int I = 0; I < 10) to the server 10 times Note: the ending\ ncannot be omitted, it means bufferedWriter.write is written by line (message + "\ n"); / / the buffer is flushed (this step cannot be omitted) bufferedWriter.flush () } Thank you for your reading, the above is the content of "what are the solutions to the Socket sticky package problem?" after the study of this article, I believe you have a deeper understanding of the solution to the Socket sticky package problem, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.