10

我正在使用 TCP 协议制作一个简单的客户端-服务器应用程序。

我知道默认情况下。recv()将阻塞，直到对方调用send()此套接字。但是有没有可能send()阻塞自己，直到对方已经recv()ed 了 msg 而不是保持send()ing 到传出队列，后来发现对方得到了多个srecv()发送的一大堆 msgsend()

换句话说。是否有可能让每个人都send()等待对方的recv()，然后才能打电话给另一个人send()？

为了说明我的问题。我将在这里发布一个简单的代码：

客户端.c

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <poll.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h> 

int main(int argc, char *argv[])
{
    int sockfd = 0;
    char sendBuff[1024];
    struct sockaddr_in serv_addr;
    int i;

    if(argc != 2)
    {
        printf("\n Usage: %s <ip of server> \n",argv[0]);
        return 1;
    } 

    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("\n Error : Could not create socket \n");
        return 1;
    } 

    memset(&serv_addr, '0', sizeof(serv_addr)); 

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(5000); 

    if(inet_pton(AF_INET, argv[1], &serv_addr.sin_addr)<=0)
    {
        printf("\n inet_pton error occured\n");
        return 1;
    } 

    if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0)
    {
        printf("\n Error : Connect Failed \n");
        return 1;
    }

    do{
        memset(sendBuff, '\0', sizeof(sendBuff));
        sprintf(sendBuff, "This is line %d", i);
        send(sockfd, sendBuff, strlen(sendBuff), 0);
        //sleep(1);
    }while(++i<100);

    return 0;
}

服务器.c

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <time.h> 

int main(int argc, char *argv[])
{
    int listenfd = 0, connfd = 0;
    struct sockaddr_in serv_addr; 

    char sendBuff[1025];
    char recvBuff[100];

    int i = 0;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    memset(&serv_addr, '0', sizeof(serv_addr));
    memset(sendBuff, '0', sizeof(sendBuff)); 

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(5000); 

    bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); 

    listen(listenfd, 10); 

    connfd = accept(listenfd, (struct sockaddr*)NULL, NULL); 

    do{  
        memset(recvBuff, '\0', sizeof(recvBuff));
        recv(connfd, recvBuff, sizeof(recvBuff),0);
        printf( "%s\n", recvBuff);
    }while(++i<100); 

    return 0;
}

我对服务器端结果的期望是打印：

This is line 0
This is line 1
This is line 2
This is line 3
...

然而，实际结果是这样的：

This is line 0
This is line 1This is line 2This is line3This is line 4
This is line 5This is line 6This is line 7This is line 8This is line 9This is line 10
This is line 11This is line 12...

然而这很容易解释：当客户端发出 asend()时，它并没有等待服务器端的recv()完成，并且由于某种原因，服务器端的recv()循环比客户端的慢send()。因此客户端的几个send()s可能会堆在一起，并被服务器作为一个整体接收。（我的解释对吗？）

实际上似乎有一个非常愚蠢和松散的解决方案。只需在循环中的每个之后添加一个sleep(1)（正如我注释掉的） 。send()我知道这会使代码非常低效，并且如果recv()循环需要更长的时间来实现一些其他复杂的操作（当程序变大时这显然是不可预测的），这将需要超过 1 秒的时间。该解决方案失败！

那么有没有更好的稳固的方式让双方相互通信，保证单单发送的msg被单单send()接收recv()呢？

4

3 回答 3

8

客户端.c

while(condition)
{
  send() from client;
  recv() from server;
}

服务器.c

recv() from client;
while(condition)
{
  send() from server; //acknowledge to client
  recv() from client;
}
于 2013-11-05T17:46:28.967 回答
7

发送者知道接收者已收到消息的唯一方法是让接收者回复。

换句话说，如果你想让发送者和接收者保持同步，你需要实现自己的显式流控制。

确实，TCP 协议要求接收者确认接收到的数据包，因此您可能认为接收者可以简单地询问 TCP 实现是否数据已被确认。这通常是可能的，尽管我不相信有这样做的跨平台方式。例如，在 Linux 上，您可以使用ioctl代码SIOCOUTQ检查出站缓冲区的大小。但据我所知，在出站缓冲区为空之前没有阻塞机制，所以你能做的最好的就是定期轮询。这并不令人满意。

无论如何，结果会产生误导，因为接收端也有一个缓冲区，如果处理是瓶颈，接收缓冲区将最先被填满。低级数据确认只表示数据已经到达接收TCP栈（即低级IP接口，一般在内核内部）。并不表示数据已经被接收进程处理过，也没有发送方查询接收缓冲区使用情况的机制。

此外，等待确认消息到达发送端通常会不必要地减慢通信速度，因为它为每个事务增加了传输延迟（接收方→发送方）。这不像您的sleep解决方案那么引人注目，但它有点相似。

如果您的消息很短，您可能会遇到Nagle 算法，该算法会导致发送者将小数据包保留一小段时间，希望可以合并多个数据包。setsockopt您可以使用,TCP_NODELAY选项关闭 TCP 连接的 Nagle 算法。但除非你确定它有用，否则不要这样做。（规范使用的TCP_NODELAY是 telnet 类型的连接，其中数据由单独的击键组成。）

于 2013-11-05T17:24:34.010 回答
2

如果您的问题是一次只处理一条消息，那么包含一个长度字段怎么样？ 发件人

int sendLen = strlen(sendBuff);
send(sockfd, &sendLen, sizeof(sendLen), 0);
send(sockfd, sendBuff, sendLen, 0);

接收者

int len = 0;
recv(connfd, &len, sizeof(len), 0);
recv(connfd, recvBuff, len, 0);

这将允许您一次读取一条消息，并将其余消息留在 tcp 缓冲区中。

请记住，上面的代码对您的发送和接收程序共享字节序和 int 大小做了很多假设。（如果它全部在一台机器上运行，你很好）它也不会检查任何错误返回，两者send()都有recv()错误的可能性。

于 2013-11-05T18:10:43.950 回答