‘壹’ recv函数返回什么值
recv函数返回其实际的字节数，如果recv在时出错，那么它返回SOCKET_ERROR。如果recv函数在等待协议接收数据时网络中断了，那么它返回0。
扩展阅读，linux recv函数详解：
1 #include <sys/socket.h>
2 ssize_t recv(int sockfd, void *buff, size_t nbytes, int flags);
recv 的前3个参数等同于read函数。
flags参数值为0或：
flags
说明
recv
send
MSG_DONTWAIT
仅本操作非阻塞
MSG_OOB 发送或接收带外数据
MSG_PEEK
窥看外来消息
MSG_WAITALL
等待所有数据
recv函数解析：
sockfd: 接收端套接字描述符
buff： 用来存放recv函数接收到的数据的缓冲区
nbytes: 指明buff的长度
flags: 一般置为0
1) recv先等待s的发送缓冲区的数据被协议传送完毕，如果协议在传送sock的发送缓冲区中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR
2)
如果套接字sockfd的发送缓冲区中没有数据或者数据被协议成功发送完毕后，recv先检查套接字sockfd的接收缓冲区，如果sockfd的接收缓
冲区中没有数据或者协议正在接收数据，那么recv就一起等待，直到把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲区中的数据
到buff中（注意协议接收到的数据可能大于buff的长度，所以在这种情况下要调用几次recv函数才能把sockfd的接收缓冲区中的数据
完。recv函数仅仅是数据，真正的接收数据是协议来完成的）
3) recv函数返回其实际的字节数，如果recv在时出错，那么它返回SOCKET_ERROR。如果recv函数在等待协议接收数据时网络中断了，那么它返回0。
4) 在unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用 recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。
‘贰’ linux支持异步的非阻塞的fsync吗
一、概念
异步：某个事情需要10s完成。而我只需要调用某个函数告诉xxx来帮我做（然后我再干其他的事情）
同步：某个事情需要10s完成，我需要一直等它完成（等10s），再能继续后面的工作。
阻塞：做某件事情，直到完成，除非超时
非阻塞：尝试做，如果不能做，就不做（直接返回），如果能做，就做。
前两者和后两者不容易区分，不过前两者更多的有涉及到多线程交互（消息）的场景。
二、举个例子
小李喝了想喝水，于是去煮开水。
1、小李把水壶放到炉子上，等待水烧开。（同步阻塞）
小李感觉这样太费时间。
2、小李把水壶放到炉子上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞）
小李还是觉得自己这样太累，于是买了把会响笛的那种水壶。水开之后，能发出声音。
3、小李把响水壶放到炉子上，等待水壶发出声音。（异步阻塞）
觉得这样傻等意义不大
5、小李把响水壶放到炉子上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞）
这样真好。
三、深入理解
阻塞就是 recv/read的时候 socket接收缓冲区要是有数据就读， 没数据我就一直睡觉赖着不走，直到有数据来了读完我才走。send/write的时候，要是发送缓冲区满了，没有空间继续发送了我也一直睡觉赖着不走，直到发送缓冲区腾出足够的空间让我把数据全部塞到发送缓冲区里我才走。（当然如果你通过setsockopt设置了读写超时，超时时间到了还是会返回-1和EAGAIN，不再睡觉等待）
非阻塞就是recv/read的时候，要是接收缓冲区有数据我就读完，没有数据我直接带着返回的-1和EGAIN走人，绝不睡觉等待耽误时间。write/send的时候， 要是发送缓冲区有足够的空间，就立刻把数据塞到发送缓冲区去，然后走人，如果发送缓存区满了，空间不足，那直接带着返回的-1和EAGAIN走人。
至于IO多路复用，首先要理解的是，操作系统为你提供了一个功能，当你的某个socket接收缓存区有数据可读，或者发送缓冲区有空间可写的时候，它可以给你一个通知。这样当配合非阻塞的socket使用时，只有当系统通知我哪个描述符可读了，我才去执行read操作，可以保证每次read都能读到有效数据而不做纯返回-1和EAGAIN的无用功。写操作类似。操作系统的这个功能通过select/poll/epoll之类的系统调用函数来使用，这些函数都可以同时监视多个描述符的读写就绪状况，这样，多个描述符的I/O操作都能在一个线程内完成，这就叫I/O多路复用，这里的“复用”指的是复用同一个线程。
至于事件驱动，其实是I/O多路复用的一个另外的称呼。
‘叁’ linux 下调用recv函数，死循环在recv函数里面，什么原因
建议你用strace看那几个线程确切是卡在哪里
而且你描述的是，死循环。 recv函数怎么会死循环？
还有，当你的系统压力变大的时候， 会出现epoll提示某socket可用，但是等你去读的时候该socket已经被关闭的情况，你看看这种情况会不会对你的程序造成影响。
----------------------------
man recv
RETURN VALUE
These calls return the number of bytes received, or -1 if an error occurred. The return value will be 0 when the peer has performed an
orderly shutdown.
你可以看到,当对端关闭socket的时候recv返回值是0。 那么作为你的程序，你又没有判断这种情况呢？ 你默认的如果是使用EPOLLET模式， 你肯定不停的读socket直到EAGAIN出现，但是如果返回值0的话，并不会出现EAGAIN。
建议你还是多用strace来查询问题所在，有时候比gdb更能直接找出原因。
、
还有再纠正一点，recv是一个linux系统调用，要么是阻塞要么是返回，不存在死循环的问题的， 死循环肯定是出在你的程序代码中。 如果你觉得recv本身不退出又占用大量cpu，那就是linux库出bug或者是内核bug了。
‘肆’ linux下设置recvfrom为非阻塞
可以使用
1 select pselect
2 poll
3可以使用fcntl给文件描述符添加O—UNBLOCK
‘伍’ recv是阻塞还是非阻塞的
网络编程函数如recv是阻塞（同步）还是非阻塞（异步）取决于在调用recv函数前创建的套接字socket是阻塞还是非阻塞。socket默认创建时设定为阻塞模式；若要将socket设定为非阻塞模式，可以在socket创建时设定为非阻塞模式，那么函数recv就是非阻塞的。
可以通过一下几种方法设定socket为非阻塞：
1.linux平台可以在利用socket()函数创建socket时指定socket是异步（非阻塞）的：
int socket(int domain, int type, int protocol);
在参数type中设置SOCK_NONBLOCK标志即可，例如：
int s = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
2.windows和linux平台accept()函数返回的socekt也是阻塞的，linux另外提供了一个accept4()函数，可以直接将socket设置为非阻塞模式：
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
只要将accept4()最后一个参数flags设置成SOCK_NONBLOCK即可。
3.除了在创建socket时，将socket设置为非阻塞模式，还可以通过以下函数来设置：
linux平台可以调用fcntl()或ioctl()函数，例如：
fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFL, 0) | O_NONBLOCK);
ioctl(sockfd, FIONBIO, 1); //1:非阻塞 0:阻塞
windows平台可调用ioctlsocket函数：
int ioctlsocket(
_In_ SOCKET s,
_In_ long cmd,
_Inout_ u_long *argp
);
将cmd参数设置为FIONBIO，*argp=0即设置成阻塞模式，而*argp非0即可设置成非阻塞模式。但windows平台一个地方需要注意，如果对一个socket调用了WSAAsyncSelect()或WSAEventSelect()函数后，你再调用ioctlsocket()函数将该socket设置为阻塞模式，则会失败，必须先调用WSAAsyncSelect()设置lEvent参数为0或调用WSAEventSelect()设置lNetworkEvents参数为0来分别禁用WSAAsyncSelect()或WSAEventSelect()，再次调用ioctlsocket()将该socket设置成阻塞模式才会成功。因为调用WSAAsyncSelect()或WSAEventSelect()函数会自动将socket设置成非阻塞模式。
‘陆’ C++ Socket如何设置Accept和Recv的非阻塞
void*CTCPClient::AUReceive(void*aInstance)
{
structtimevaltv_out;
CTCPClient*pInstance=(CTCPClient*)aInstance;
fd_setsockfd;
pInstance->m_IsExit=false;
charReceiveDataInfo[1024]={0};
charTemp[4]={0};
while(pInstance->m_IsExit==false)
{
if(pInstance->m_socket==SOCKETERROR)
{
FD_ZERO(&sockfd);
}
else
{
FD_ZERO(&sockfd);
FD_SET(pInstance->m_socket,&sockfd);
}
fd_setmySet=sockfd;
memset(ReceiveDataInfo,0,1024);
intMax_ID=pInstance->m_socket;
intposition=0;
tv_out.tv_sec=0;
tv_out.tv_usec=1000;
if(select(Max_ID+1,&mySet,NULL,NULL,&tv_out)>0)//主要这一句
{
longnBytesRead=0;
unsignedlongnBytesToRecv=pInstance->mreceivebuflen-pInstance->hasrecvlen;
pInstance->recvsignal.Wait();
if(pInstance->m_socket==SOCKETERROR)
{
FD_ZERO(&sockfd);
pInstance->recvsignal.Release();
continue;
}
nBytesRead=recv(pInstance->m_socket,(char*)pInstance->mreceivebuf+pInstance->hasrecvlen,nBytesToRecv,0);
pInstance->recvsignal.Release();
if(nBytesRead==-1||nBytesRead==0)
{
pInstance->m_CSocket.SocketClose(pInstance->m_socket);
FD_ZERO(&sockfd);
pInstance->m_socket=SOCKETERROR;
continue;
}
pInstance->hasrecvlen+=nBytesRead;
pInstance->m_CLog->ddprintf("CTCPClient","AUReceive",1,"recvapackage!");
pInstance->m_CLog->ddprintf("CTCPClient","AUReceive",1,"recvlenis%ld",nBytesRead);
if((pInstance->FindCompletePackage(pInstance->receive,nBytesRead,pInstance->mreceivebuf))==false)
{
continue;
}
//printf("validlenis%d ",pInstance->validlen);
pInstance->hasrecvlen=0;
if(pInstance->validlen<8)
{
pInstance->m_CLog->ddprintf("CTCPClient","AUReceive",1,"receivedataiserror(leniserror)!");
continue;
}
for(inti=0;i<pInstance->validlen;i++)
{
sprintf(Temp,"%2x-",pInstance->receive[i]);
strcat(ReceiveDataInfo,Temp);
}
pInstance->m_CLog->ddprintf("CTCPClient","AUReceive",1,"recvdatais:%s",ReceiveDataInfo);
unsignedintrecvSN=Char2Int(pInstance->receive);
position+=4;
unsignedintrecvCMD=Char2Short(pInstance->receive+position);
position+=2;
unsignedlongbuflen=Char2Short(pInstance->receive+position);
position+=2;
if(pInstance->validlen-position!=buflen)
{
pInstance->m_CLog->ddprintf("CTCPClient","AUReceive",1,"receivedataiserror(lenerror)!");
continue;
}
stCommandnewReceiveCommand;
newReceiveCommand.CmdSN=recvSN;
//newReceiveCommand.DataBuffer="";
boolrest=pInstance->FindSentCommand(newReceiveCommand);
if(rest==false)
{
pInstance->m_CLog->ddprintf("CTCPClient","AUReceive",1,"receivedataiserror(SNcannotfind)!");
continue;
}
if(newReceiveCommand.CmdCode!=recvCMD)
{
pInstance->m_CLog->ddprintf("CTCPClient","AUReceive",1,"receivedataiserror(CMDiserror)!");
continue;
}
char*RecvData=newchar[buflen];
memcpy(RecvData,pInstance->receive+position,buflen);
pInstance->UpdateSentCommand(recvSN,buflen,RecvData);
newReceiveCommand.WaitEvent->Release();
pInstance->m_CLog->ddprintf("CTCPClient","AUReceive",1,"sendasignalofrecv!");
delete[]RecvData;
}
else
Csleep(100);
}
//pInstance->m_ThdRecv.ThreadExit();
returnNULL;
}
这个是recv设置非阻塞的方式，accept也是差不多
‘柒’ linux网络编程，为什么要将文件描述符设置成非阻塞模式
非阻塞IO 和阻塞IO：
在网络编程中对于一个网络句柄会遇到阻塞IO 和非阻塞IO 的概念, 这里对于这两种socket 先做一下说明：
基本概念：
阻塞IO::
socket 的阻塞模式意味着必须要做完IO 操作（包括错误）才会
返回。
非阻塞IO::
非阻塞模式下无论操作是否完成都会立刻返回，需要通过其他方
式来判断具体操作是否成功。(对于connect，accpet操作，通过select判断，
对于recv，recvfrom，send，sendto通过返回值+错误码来判断)
IO模式设置：
SOCKET
对于一个socket 是阻塞模式还是非阻塞模式的处理方法::
方法：：
用fcntl 设置;用F_GETFL获取flags,用F_SETFL设置flags|O_NONBLOCK;
同时，recv,send 时使用非阻塞的方式读取和发送消息，即flags设置为MSG_DONTWAIT
实现
fcntl 函数可以将一个socket 句柄设置成非阻塞模式:
flags = fcntl(sockfd, F_GETFL, 0); //获取文件的flags值。
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK); //设置成非阻塞模式；
flags = fcntl(sockfd,F_GETFL,0);
fcntl(sockfd,F_SETFL,flags&~O_NONBLOCK); //设置成阻塞模式；
并在接收和发送数据时:
将recv, send 函数的最后有一个flag 参数设置成MSG_DONTWAIT
recv(sockfd, buff, buff_size,MSG_DONTWAIT); //非阻塞模式的消息发送
send(scokfd, buff, buff_size, MSG_DONTWAIT); //非阻塞模式的消息接受
普通文件
对于文件的阻塞模式还是非阻塞模式::
方法1、open时，使用O_NONBLOCK；
方法2、fcntl设置，使用F_SETFL，flags|O_NONBLOCK；
消息队列
对于消息队列消息的发送与接受::
//非阻塞 msgsnd(sockfd,msgbuf,msgsize(不包含类型大小),IPC_NOWAIT)
//阻塞 msgrcv(scokfd,msgbuf,msgsize(**),msgtype,IPC_NOWAIT);
读
阻塞与非阻塞读的区别: //阻塞和非阻塞的区别在于没有数据到达的时候是否立刻返回．
读(read/recv/msgrcv):
读的本质来说其实不能是读,在实际中, 具体的接收数据不是由这些调用来进行,是由于系统底层自动完成的。read 也好,recv 也好只负责把数据从底层缓冲 到我们指定的位置.
对于读来说(read, 或者recv) ::
阻塞情况下::
在阻塞条件下，read/recv/msgrcv的行为::
1、如果没有发现数据在网络缓冲中会一直等待，
2、当发现有数据的时候会把数据读到用户指定的缓冲区，但是如果这个时候读到的数据量比较少，比参数中指定的长度要小，read 并不会一直等待下去，而是立刻返回。
read 的原则::是数据在不超过指定的长度的时候有多少读多少，没有数据就会一直等待。
所以一般情况下::我们读取数据都需要采用循环读的方式读取数据，因为一次read 完毕不能保证读到我们需要长度的数据，
read 完一次需要判断读到的数据长度再决定是否还需要再次读取。
非阻塞情况下::
在非阻塞的情况下，read 的行为::
1、如果发现没有数据就直接返回，
2、如果发现有数据那么也是采用有多少读多少的进行处理．
所以::read 完一次需要判断读到的数据长度再决定是否还需要再次读取。
对于读而言:: 阻塞和非阻塞的区别在于没有数据到达的时候是否立刻返回．
recv 中有一个MSG_WAITALL 的参数::
recv(sockfd, buff, buff_size, MSG_WAITALL),
在正常情况下recv 是会等待直到读取到buff_size 长度的数据，但是这里的WAITALL 也只是尽量读全，在有中断的情况下recv 还是可能会被打断，造成没有读完指定的buff_size的长度。
所以即使是采用recv + WAITALL 参数还是要考虑是否需要循环读取的问题，在实验中对于多数情况下recv (使用了MSG_WAITALL)还是可以读完buff_size，
所以相应的性能会比直接read 进行循环读要好一些。
注意:: //使用MSG_WAITALL时，sockfd必须处于阻塞模式下，否则不起作用。
//所以MSG_WAITALL不能和MSG_NONBLOCK同时使用。
要注意的是使用MSG_WAITALL的时候，sockfd 必须是处于阻塞模式下，否则WAITALL不能起作用。
写
阻塞与非阻塞写的区别: //
写(send/write/msgsnd)::
写的本质也不是进行发送操作,而是把用户态的数据 到系统底层去,然后再由系统进行发送操作,send，write返回成功，只表示数据已经 到底层缓冲,而不表示数据已经发出,更不能表示对方端口已经接收到数据.
对于write(或者send)而言，
阻塞情况下:: //阻塞情况下，write会将数据发送完。(不过可能被中断)
在阻塞的情况下，是会一直等待，直到write 完，全部的数据再返回．这点行为上与读操作有所不同。
原因::
读，究其原因主要是读数据的时候我们并不知道对端到底有没有数据，数据是在什么时候结束发送的，如果一直等待就可能会造成死循环，所以并没有去进行这方面的处理；
写，而对于write, 由于需要写的长度是已知的，所以可以一直再写，直到写完．不过问题是write 是可能被打断吗，造成write 一次只write 一部分数据, 所以write 的过程还是需要考虑循环write, 只不过多数情况下一次write 调用就可能成功.
非阻塞写的情况下:: //
非阻塞写的情况下，是采用可以写多少就写多少的策略．与读不一样的地方在于，有多少读多少是由网络发送的那一端是否有数据传输到为标准，但是对于可以写多少是由本地的网络堵塞情况为标准的，在网络阻塞严重的时候，网络层没有足够的内存来进行写操作，这时候就会出现写不成功的情况，阻塞情况下会尽可能(有可能被中断)等待到数据全部发送完毕， 对于非阻塞的情况就是一次写多少算多少,没有中断的情况下也还是会出现write 到一部分的情况.
‘捌’ c语言的recv（）非阻塞方法怎么弄哦
需要将recv设置超时，Linux下设置超时如下：
//设置发送超时
struct timeval timeout={3,0};//3s
setsockopt(socket，SOL_SOCKET,SO_SNDTIMEO，(char *)&timeout,sizeof(struct timeval));
//设置接收超时
setsockopt(socket，SOL_SOCKET,SO_RCVTIMEO，(char *)&timeout,sizeof(struct timeval));
windows下设置超时如下：
int timeout = 3000; //3s
int ret=setsockopt(sock_fd,SOL_SOCKET,SO_SNDTIMEO,&timeout,sizeof(timeout));
int ret=setsockopt(sock_fd,SOL_SOCKET,SO_RCVTIMEO,&timeout,sizeof(timeout));