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

This article introduces the relevant knowledge of "how to solve the Socket sticky package problem". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Question 1: is there a sticky package problem in TCP?

Let's start with the answer: TCP itself does not have sticky packets or semi-packets, because TCP is essentially a transmission control protocol (Transmission Control Protocol,TCP), a connection-oriented, reliable, byte-stream-based transport layer communication protocol defined by IETF's RFC 793.

The so-called protocol is essentially a contract, just like the Java programming convention using hump nomenclature, the meaning of the agreement is to enable both sides of the communication to exchange messages normally, so how does the sticky packet and half-packet problem arise?

This is because in the interaction of TCP, the data is transmitted in the form of byte stream, while the transmission of "stream" has no boundary, and the attribution of the message cannot be distinguished because there is no boundary, which leads to the problem of sticky packet and semi-packet (for the definition of sticky packet and semi-packet, see the previous article for details). Therefore, there are no sticky packet and semi-packet problems in TCP protocol itself, but sticky packet and semi-packet problems will occur if the boundary of the flow can not be determined effectively in use.

Question 2: is the delimiter the best solution?

Frankly speaking, after being patiently enlightened by everyone in the comment area, I also realized that there are some limitations in using the Terminator as the final solution, for example, if there is a Terminator in the middle of a message, it will cause a half-packet problem, so if it is a complex string, the content should be encoded and decoded in order to ensure the correctness of the Terminator.

Question 3: is Socket efficient?

The answer to this question is no. In fact, the application scenario has been described at the beginning of the above: "traditional Socket programming". The meaning of learning it is to understand some of the earlier and lower-level knowledge. Of course, as a supplement, this article will provide a more efficient message communication solution-Netty communication.

After talking about the above questions, let's first supplement the code implementation mentioned in the previous article, which divides the message into the header and the body.

Encapsulating the header and body of the message

Before we start writing about the server and client, let's write a message wrapper class that can be used to encapsulate the message into a header and a message body, as shown in the following figure:

The length of the message body is stored in the message header, so that the boundary of the message is determined, and the problem of sticky packet and semi-packet is solved.

1. Message wrapper class

Two methods are provided in the message wrapper class: one is to convert the message into a message header + message body, and the other is to read the message header. The specific implementation code is as follows:

/ * message wrapper class * / class SocketPacket {/ / the length of header storage (8 bytes) static final int HEAD_SIZE = 8 / * encapsulate the protocol as: protocol header + protocol body * @ param context message body (String type) * @ return byte [] * / public byte [] toBytes (String context) {/ / protocol body byte array byte [] bodyByte = context.getBytes (); int bodyByteLength = bodyByte.length / / final encapsulation object byte [] result = new byte [head _ SIZE + bodyByteLength]; / / convert int to byte [] NumberFormat numberFormat = NumberFormat.getNumberInstance (); numberFormat.setMinimumIntegerDigits (HEAD_SIZE); numberFormat.setGroupingUsed (false); / / Protocol header byte array byte [] headByte = numberFormat.format (bodyByteLength). GetBytes () / / package protocol header System.arraycopy (headByte, 0, result, 0, HEAD_SIZE); / / package protocol body System.arraycopy (bodyByte, 0, result, HEAD_SIZE, bodyByteLength); return result } / * get the content of the header (that is, the length of the message body) * @ param inputStream * @ return * / public int getHeader (InputStream inputStream) throws IOException {int result = 0; byte [] bytes = new byte [head _ SIZE]; inputStream.read (bytes, 0, HEAD_SIZE) / / get the byte length of the message body result = Integer.valueOf (new String (bytes)); return result;}}

two。 Write a client

Next, let's define the client. In the client, we add a set of messages to be sent, and randomly send a message to the server. The implementation code is as follows:

/ * client * / class MySocketClient {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", 9093) / / send message collection (send a message at random) final String [] message = {"Hi,Java.", "Hi,SQL~", "follow official account | Java Chinese community."}; / / create protocol encapsulation object SocketPacket socketPacket = new SocketPacket () Try (OutputStream outputStream = socket.getOutputStream ()) {/ / send a message for (int I = 0; I) to the server 10 times

< 10; i++) { // 随机发送一条消息 String msg = message[new Random().nextInt(message.length)]; // 将内容封装为:协议头+协议体 byte[] bytes = socketPacket.toBytes(msg); // 发送消息 outputStream.write(bytes, 0, bytes.length); outputStream.flush(); } } } } 3.编写服务器端 服务器端我们使用线程池来处理每个客户端的业务请求，实现代码如下： /** * 服务器端 */ class MySocketServer { public static void main(String[] args) throws IOException { // 创建 Socket 服务器端 ServerSocket serverSocket = new ServerSocket(9093); // 获取客户端连接 Socket clientSocket = serverSocket.accept(); // 使用线程池处理更多的客户端 ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100, TimeUnit.SECONDS, new LinkedBlockingQueue(1000)); threadPool.submit(() ->

{/ / client message processing processMessage (clientSocket);});} / * * client message processing * @ param clientSocket * / private static void processMessage (Socket clientSocket) {/ / Socket encapsulated object SocketPacket socketPacket = new SocketPacket () / / get the message object try (InputStream inputStream = clientSocket.getInputStream ()) {while (true) {/ / get the message header (that is, the length of the message body) int bodyLength = socketPacket.getHeader (inputStream); / / the message body byte array byte [] bodyByte = new byte [bodyLength] / / the actual number of bytes per read int readCount = 0; / / message body assignment subscript int bodyIndex = 0; / / the length defined in the loop receive message header while (bodyIndex)

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.