如果客户端发送多个缓冲区而不进行睡眠，为什么tcp服务器只接收一个缓冲区？

如果我在某个时间间隔后发送缓冲区，则我的客户端将正确发送到服务器。但如果我发送没有间隔的消息，服务器将接收一个缓冲区。例如，如果我发送两个缓冲区“message1”和“message2”，并在这两个发送操作之间放置1秒睡眠，服务器将接收两个缓冲区并打印message1“\n”message2。但如果我在没有睡眠的情况下发送这两个缓冲区，服务器将得到一个缓冲区并打印message1message2。我不明白为什么会这样。我的服务器和客户端代码如下

服务器.c

            #include<stdio.h>
            #include<string.h>    //strlen
            #include<stdlib.h>    //strlen
            #include<sys/socket.h>
            #include<arpa/inet.h> //inet_addr
            #include<unistd.h>    //write

            #include<pthread.h> //for threading , link with lpthread

            void *connection_handler(void *);

            int main(int argc, char *argv[])
            {
                int socket_desc, new_socket, c, *new_sock;
                struct sockaddr_in server, client;
                char *message;

                //Create socket
                socket_desc = socket(AF_INET, SOCK_STREAM, 0);
                if (socket_desc == -1)
                {
                    printf("Could not create socket");
                }

                //Prepare the sockaddr_in structure
                server.sin_family = AF_INET;
                server.sin_addr.s_addr = INADDR_ANY;
                server.sin_port = htons(10240);

                //Bind
                if (bind(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0)
                {
                    puts("bind failed");
                    return 1;
                }
                puts("bind done");

                //Listen
                listen(socket_desc, 3);

                //Accept and incoming connection
                puts("Waiting for incoming connections...");
                c = sizeof(struct sockaddr_in);
                while ((new_socket = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)))
                {
                    puts("Connection accepted");

                    //Reply to the client
            //      message = "Hello Client , I have received your connection. And now I will assign a handler for you\n";
            //      write(new_socket, message, strlen(message));

                    pthread_t sniffer_thread;
                    new_sock = malloc(1);
                    *new_sock = new_socket;

                    if (pthread_create(&sniffer_thread, NULL, connection_handler, (void*)new_sock) < 0)
                    {
                        perror("could not create thread");
                        return 1;
                    }

                    //Now join the thread , so that we dont terminate before the thread
                    //pthread_join( sniffer_thread , NULL);
                    puts("Handler assigned");
                }

                if (new_socket<0)
                {
                    perror("accept failed");
                    return 1;
                }
                while (1);
                return 0;
            }



            void *connection_handler(void *socket_desc)
            {
                //Get the socket descriptor
                int sock = *(int*)socket_desc;
                int read_size;
                char *message, client_message[2000];

                //Send some messages to the client
            //  message = "Greetings! I am your connection handler\n";
            //  write(sock, message, strlen(message));
            // 
            //  message = "Now type something and i shall repeat what you type \n";
            //  write(sock, message, strlen(message));

                //Receive a message from client
                while ((read_size = recv(sock, client_message, 2000, 0)) > 0)
                {
                    puts(client_message);
                    //Send the message back to client
                    //write(sock, client_message, strlen(client_message));
                    memset(client_message, 0, sizeof(client_message));
                }

                if (read_size == 0)
                {
                    puts("Client disconnected");
                    fflush(stdout);
                }
                else if (read_size == -1)
                {
                    perror("recv failed");
                }

                //Free the socket pointer
                free(socket_desc);

                return 0;
            }

#包括
#包括//strlen
#包括//strlen
#包括
#包括//inet\u addr
#包括//写入
#包括//对于线程，使用lpthread链接
void*连接处理程序（void*）；
int main（int argc，char*argv[]）
{
int插座描述，新插座，c，*新插座；
服务器、客户端中的结构sockaddr_；
字符*消息；
//创建套接字
socket\u desc=socket（AF\u INET，SOCK\u STREAM，0）；
如果（套接字描述==-1）
{
printf（“无法创建套接字”）；
}
//在结构中准备sockaddr_
server.sinu family=AF\u INET；
server.sin\u addr.s\u addr=INADDR\u ANY；
server.sin_port=htons（10240）；
//束缚
if（绑定（socket_desc，（struct sockaddr*）&server，sizeof（server））<0
{
看跌期权（“绑定失败”）；
返回1；
}
看跌期权（“绑定完成”）；
//听
听（插座描述，3）；
//接受和传入连接
puts（“等待传入连接…”）；
c=sizeof（结构sockaddr_in）；
而（（新套接字=接受（套接字描述，（结构sockaddr*）和客户端，（socklen\u t*）和c）））
{
看跌期权（“已接受连接”）；
//回复客户
//message=“你好，客户端，我已收到您的连接。现在我将为您分配一个处理程序\n”；
//写入（新的_套接字、消息、strlen（消息））；
pthread\u t sniffer\u线程；
新_sock=malloc（1）；
*新_插座=新_插座；
if（pthread_create（&sniffer_thread，NULL，connection_handler，（void*）new_sock）<0）
{
perror（“无法创建线程”）；
返回1；
}
//现在加入线程，这样我们就不会在线程之前终止
//pthread_join（嗅探器_线程，NULL）；
看跌期权（“指定的处理人”）；
}
如果（新的_插座0）
{
puts（客户端消息）；
//将消息发送回客户端
//写入（sock、client_消息、strlen（client_消息））；
memset（client_message，0，sizeof（client_message））；
}
如果（读取大小==0）
{
出售（“客户断开连接”）；
fflush（stdout）；
}
else if（读取大小==-1）
{
perror（“recv失败”）；
}
//释放套接字指针
自由（插座描述）；
返回0；
}

客户c

            #include<stdio.h>
            #include<string.h>    //strlen
            #include<sys/socket.h>
            #include<arpa/inet.h> //inet_addr

            int main(int argc, char *argv[])
            {
                int socket_desc;
                struct sockaddr_in server;
                char *message, server_reply[2000];

                //Create socket
                socket_desc = socket(AF_INET, SOCK_STREAM, 0);
                if (socket_desc == -1)
                {
                    printf("Could not create socket");
                }

                server.sin_addr.s_addr = inet_addr("192.168.246.26");
                server.sin_family = AF_INET;
                server.sin_port = htons(10240);

                //Connect to remote server
                if (connect(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0)
                {
                    puts("connect error");
                    return 1;
                }

                puts("Connected\n");

                //Send some data
                message = "nayan";
                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "Mazhar vai";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "Sarwar vai";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "joy";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "sumon";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "rahim";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "karim";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }

                /*sleep(1);*/
                message = NULL;
                message = "jamal";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/
                message = NULL;
                message = "kamal";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                /*sleep(1);*/ 
                message = NULL;
                message = "salam";

                if (send(socket_desc, message, strlen(message), 0) < 0)
                {
                    puts("Send failed");
                    return 1;
                }
                //Receive a reply from the server
            //  if (recv(socket_desc, server_reply, 2000, 0) < 0)
            //  {
            //      puts("recv failed");
            //  }
            //  puts("Reply received\n");
            //  puts(server_reply);

                return 0;
            }

#包括
#包括//strlen
#包括
#包括//inet\u addr
int main（int argc，char*argv[]）
{
内部插座描述；
服务器中的结构sockaddr_；
char*消息，服务器_回复[2000]；
//创建套接字
socket\u desc=socket（AF\u INET，SOCK\u STREAM，0）；
如果（套接字描述==-1）
{
printf（“无法创建套接字”）；
}
server.sin_addr.s_addr=inet_addr（“192.168.246.26”）；
server.sinu family=AF\u INET；
server.sin_port=htons（10240）；
//连接到远程服务器
if（connect（socket_desc，（struct sockaddr*）&server，sizeof（server））<0
{
puts（“连接错误”）；
返回1；
}
放置（“已连接”）；
//发送一些数据
message=“纳扬”；
如果（发送（套接字描述，消息，strlen（消息），0）<0）
{
看跌期权（“发送失败”）；
返回1；
}
/*睡眠（1）*/
消息=NULL；
message=“Mazhar vai”；
如果（发送（套接字描述，消息，strlen（消息），0）<0）
{
看跌期权（“发送失败”）；
返回1；
}
/*睡眠（1）*/
消息=NULL；
message=“Sarwar vai”；
如果（发送（套接字描述，消息，strlen（消息），0）<0）
{
看跌期权（“发送失败”）；
返回1；
}
/*睡眠（1）*/
消息=NULL；
message=“joy”；
如果（发送（套接字描述，消息，strlen（消息），0）<0）
{
看跌期权（“发送失败”）；
返回1；
}
/*睡眠（1）*/
消息=NULL；
message=“sumon”；
如果（发送（套接字描述，消息，strlen（消息），0）<0）
{
看跌期权（“发送失败”）；