linux设置socket超时
⑴ linux socket 连接超时 怎么解决
今天发现自己的系统存在很严重缺陷，当前台关闭的时候后台就无法正常工作，原因很好定位，后台的socket连接超时时间过长，系统默认时间好像是75秒，于是找资料，根据下边文章中的内容解决了，把超时时间设为5秒后，感觉好多了。看来还有好多东西需要慢慢挖掘阿！
如何设置socket的Connect超时(linux)
[From]http://dev.cbw.com/c/c/200510195601_4292587.shtml
1.首先将标志位设为Non-blocking模式，准备在非阻塞模式下调用connect函数
2.调用connect，正常情况下，因为TCP三次握手需要一些时间；而非阻塞调用只要不能立即完成就会返回错误，所以这里会返回EINPROGRESS，表示在建立连接但还没有完成。
3.在读套接口描述符集(fd_set rset)和写套接口描述符集(fd_set wset)中将当前套接口置位（用FD_ZERO()、FD_SET()宏），并设置好超时时间(struct timeval *timeout)
4.调用select( socket, &rset, &wset, NULL, timeout )
返回0表示connect超时
如果你设置的超时时间大于75秒就没有必要这样做了，因为内核中对connect有超时限制就是75秒。
[From]http://www.ycgczj.com.cn/34733.html
网络编程中socket的分量我想大家都很清楚了，socket也就是套接口，在套接口编程中，提到超时的概念，我们一下子就能想到3个：发送超时，接收超时，以及select超时（注： select函数并不是只用于套接口的，但是套接口编程中用的比较多），在connect到目标主机的时候，这个超时是不由我们来设置的。不过正常情况下这个超时都很长，并且connect又是一个阻塞方法，一个主机不能连接，等着connect返回还能忍受，你的程序要是要试图连接多个主机，恐怕遇到多个不能连接的主机的时候，会塞得你受不了的。我也废话少说，先说说我的方法，如果你觉得你已掌握这种方法，你就不用再看下去了，如果你还不了解，我愿意与你分享。本文是已在Linux下的程序为例子，不过拿到Windows中方法也是一样，无非是换几个函数名字罢了。
Linux中要给connect设置超时，应该是有两种方法的。一种是该系统的一些参数，这个方法我不讲，因为我讲不清楚:P，它也不是编程实现的。另外一种方法就是变相的实现connect的超时，我要讲的就是这个方法，原理上是这样的：
1．建立socket
2．将该socket设置为非阻塞模式
3．调用connect()
4．使用select()检查该socket描述符是否可写（注意，是可写）
5．根据select()返回的结果判断connect()结果
6．将socket设置为阻塞模式（如果你的程序不需要用阻塞模式的，这步就省了，不过一般情况下都是用阻塞模式的，这样也容易管理）
如果你对网络编程很熟悉的话，其实我一说出这个过程你就知道怎么写你的程序了，下面给出我写的一段程序，仅供参考。
/******************************
* Time out for connect()
* Write by Kerl W
******************************/
#include <sys/socket.h>
#include <sys/types.h>
#define TIME_OUT_TIME 20 //connect超时时间20秒
int main(int argc , char **argv)
{
………………
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0) exit(1);
struct sockaddr_in serv_addr;
………//以服务器地址填充结构serv_addr
int error=-1, len;
len = sizeof(int);
timeval tm;
fd_set set;
unsigned long ul = 1;
ioctl(sockfd, FIONBIO, &ul); //设置为非阻塞模式
bool ret = false;
if( connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
{
tm.tv_set = TIME_OUT_TIME;
tm.tv_uset = 0;
FD_ZERO(&set);
FD_SET(sockfd, &set);
if( select(sockfd+1, NULL, &set, NULL, &tm) > 0)
{
getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, (socklen_t *)&len);
if(error == 0) ret = true;
else ret = false;
} else ret = false;
}
else ret = true;
ul = 0;
ioctl(sockfd, FIONBIO, &ul); //设置为阻塞模式
if(!ret)
{
close( sockfd );
fprintf(stderr , "Cannot Connect the server!n");
return;
}
fprintf( stderr , "Connected!n");
//下面还可以进行发包收包操作
……………
}
以上代码片段，仅供参考，也是为初学者提供一些提示，主要用到的几个函数，select, ioctl, getsockopt都可以找到相关资料，具体用法我这里就不赘述了，你只需要在linux中轻轻的敲一个man <函数名>就能够看到它的用法。
此外我需要说明的几点是，虽然我们用ioctl把套接口设置为非阻塞模式，不过select本身是阻塞的，阻塞的时间就是其超时的时间由调用select 的时候的最后一个参数timeval类型的变量指针指向的timeval结构变量来决定的，timeval结构由一个表示秒数的和一个表示微秒数（long类型）的成员组成，一般我们设置了秒数就行了，把微妙数设为0（注：1秒等于100万微秒）。而select函数另一个值得一提的参数就是上面我们用到的fd_set类型的变量指针。调用之前，这个变量里面存了要用select来检查的描述符，调用之后，针对上面的程序这里面是可写的描述符，我们可以用宏FD_ISSET来检查某个描述符是否在其中。由于我这里只有一个套接口描述符，我就没有使用FD_ISSET宏来检查调用select之后这个sockfd是否在set里面，其实是需要加上这个判断的。不过我用了getsockopt来检查，这样才可以判断出这个套接口是否是真的连接上了，因为我们只是变相的用select来检查它是否连接上了，实际上select检查的是它是否可写，而对于可写，是针对以下三种条件任一条件满足时都表示可写的：
1）套接口发送缓冲区中的可用控件字节数大于等于套接口发送缓冲区低潮限度的当前值，且或者i)套接口已连接，或者ii)套接口不要求连接（UDP方式的）
2）连接的写这一半关闭。
3）有一个套接口错误待处理。
这样，我们就需要用getsockopt函数来获取套接口目前的一些信息来判断是否真的是连接上了，没有连接上的时候还能给出发生了什么错误，当然我程序中并没有标出那么多状态，只是简单的表示可连接/不可连接。
下面我来谈谈对这个程序测试的结果。我针对3种情形做了测试：
1． 目标机器网络正常的情况
可以连接到目标主机，并能成功以阻塞方式进行发包收包作业。
2． 目标机器网络断开的情况
在等待设置的超时时间（上面的程序中为20秒）后，显示目标主机不能连接。
3． 程序运行前断开目标机器网络，超时时间内，恢复目标机器的网络
在恢复目标主机网络连接之前，程序一只等待，恢复目标主机后，程序显示连接目标主机成功，并能成功以阻塞方式进行发包收包作业。
以上各种情况的测试结果表明，这种设置connect超时的方法是完全可行的。我自己是把这种设置了超时的connect封装到了自己的类库，用在一套监控系统中，到目前为止，运行还算正常。这种编程实现的connect超时比起修改系统参数的那种方法的有点就在于它只用于你的程序之中而不影响系统。
⑵ linuxsocket无法断开
c++
Linux环境中使用socket进行UDP和TCP多线程通信无法关闭socket
（^v^）
原创
关注
0点赞·641人阅读
在Linux下，使用QT编程网络通信，为提高通信效率，使用原始socket进行网络编程，在QT线程中经常出现线程无法退出，原因来源于socket无法关闭。
线程处理如下：
void communicationClass::run()
{
// 开启数据处理线程
#ifdef Q_OS_LINUX
//配置服务器信息
bzero(&m_sServer_addr, sizeof(m_sServer_addr));
m_sServer_addr.sin_family = AF_INET;
//设置为IPV4通信
m_sServer_addr.sin_addr.s_addr = htonl(INADDR_ANY);
//设置目的ip
m_sServer_addr.sin_addr.s_addr = inet_addr(m_strSendIP.toStdString().c_str());
//设置目的端口去链接服务器
m_sServer_addr.sin_port = htons(m_ui16Port);
//配置本地信息
bzero(&m_sLocal_addr, sizeof(m_sLocal_addr));
m_sLocal_addr.sin_family = AF_INET;
//设置为IPV4通信
//loc_addr.sin_addr.s_addr = htonl(INADDR_ANY);
//设置目的ip
m_sLocal_addr.sin_addr.s_addr = htonl(INADDR_ANY);
//设置本地端口去链接服务器
m_sLocal_addr.sin_port = htons(m_ui16Port);
m_iSockedFd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //设置UDP报文传输 0表示默认 SOCK_DGRAM 默认使用UDP
//其中第三位 0 是调用方式标志位嫌岩吵，设置socket通方式，比如非阻塞
if(m_iSockedFd<0)
{
emit signal_networkInfoError(false, "枣竖socket create failure");
return;
}
//将本地配置使用bind绑定
int ret = bind(m_iSockedFd,(struct sockaddr*)&m_sLocal_addr,sizeof (m_sLocal_addr));
if(ret < 0)
{
emit signal_networkInfoError(false, "socket bind failure");
return;
}
emit signal_networkInfoError(true, "network success");
// 线程芹侍循环等待数据
while (!isInterruptionRequested())
{
char buf[1600];
int count = 0;
socklen_t i_server_addr_len = sizeof(m_sServer_addr);
count = recvfrom(m_iSockedFd, buf, sizeof(buf), 0, (struct sockaddr*)&m_sServer_addr,&i_server_addr_len);
if (count > 0)
{
// 组装返回数据buffer
QByteArray arrayRecvData;
arrayRecvData.resize(count);
memcpy(arrayRecvData.data(), buf, count);
// qDebug() << "接收到数据:" << arrayRecvData.size();
emit signal_recvNetworkData(arrayRecvData);
}
msleep(1);
}
#endif
#ifdef Q_OS_WIN32
// 确定版本信息
WSADATA wsaData;
WSAStartup(MAKEWORD(2, 2), &wsaData);
if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
{
emit signal_networkInfoError(false, "Version failure");
return;
}
// 创建socket
m_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (INVALID_SOCKET == m_socket)
{
emit signal_networkInfoError(false, "socket create failure");
return;
}
// 初始化本地地址信息
//地址族
m_sLocal_addr.sin_family = AF_INET;
//端口
m_sLocal_addr.sin_port = htons(m_ui16Port);
//IP
m_sLocal_addr.sin_addr.s_addr = htonl(INADDR_ANY);
// 初始化服务器地址信息
//地址族
m_sServer_addr.sin_family = AF_INET;
//端口
m_sServer_addr.sin_port = htons(m_ui16Port);
//IP
m_sServer_addr.sin_addr.s_addr = inet_addr(m_strSendIP.toStdString().c_str());
int ret = bind(m_socket, (sockaddr*)&m_sLocal_addr, sizeof(m_sLocal_addr));
if (ret < 0)
{
emit signal_networkInfoError(false, "socket bind failure");
return;
}
emit signal_networkInfoError(true, "network success");
// 线程循环等待数据
while (!isInterruptionRequested())
{
char buf[1600];
// memset(buf,0,1600*sizeof(char));
int count = 0;
count = recv(m_socket, buf, sizeof(buf), 0);
if (count > 0)
{
// 组装返回数据buffer
QByteArray arrayRecvData;
arrayRecvData.resize(count);
memcpy(arrayRecvData.data(), buf, count);
emit signal_recvNetworkData(arrayRecvData);
}
}
#endif
qDebug() << "communicationClass quit";
}
复制
退出线程：
#ifdef Q_OS_LINUX
close(m_iSockedFd);
#endif
#ifdef Q_OS_WIN32
closesocket(m_socket);
WSACleanup();
#endif
requestInterruption();
复制
在windows下线程能优雅退出。
但在Linux中会出现close（）关闭socket失败。
解决方法：
#include<sys/socket.h>
int shutdown(int sockfd,int how);
TCP连接是双向的(是可读写的),当我们使用close时,会把读写通道都关闭,有时侯我们希望只关闭一个方向,这个时候我们能够使用shutdown.
how的方式有三种分别是
SHUT_RD（0）：关闭sockfd上的读功能，此选项将不允许sockfd进行读操作。
SHUT_WR（1）：关闭sockfd的写功能，此选项将不允许sockfd进行写操作。
SHUT_RDWR（2）：关闭sockfd的读写功能。
成功则返回0，错误返回-1，错误码errno：EBADF表示sockfd不是一个有效描述符；ENOTCONN表示sockfd未连接；ENOTSOCK表示sockfd是一个文件描述符而不是socket描述符。
⑶ 我想请教LINUX 下socket 超时设置的问题
我建议 阅读 《unix网络编程》里面有很详细的解释
举个例子：
你可以把socket的IO操作看做是等人
阻塞：
你站在和人越好的地毁念方等人，你们的约定了一个时槐森间，当你等的时间超过了这个时间后你就可以离开这个地点去干其他的事情，否则你将继续在这里等人。而INFINIT就是无限等待下去
非阻塞：
就是你不需要站在越好的地点等人，你可以作在离这个地点很近的纤明困一个咖啡厅喝茶听音乐，但你能够看到这个约定地点的情况，一旦有人来你就可以走过去和那个人见面
阻塞：人来了以后你可以第一时间见到，而不用别人等你
非阻塞：和你正在做的事情有关，如果你在坐在咖啡厅看电视，就很有可能造成别人等你的情况了
⑷ LINUX C 进行TCP网络连接，怎样设置连接超时时间
如果你确定,真的不需要等这么久,或者用户希望可以随时中上连接过程,那么一般是用 非阻塞模式来做的. 看看我的这段连接代码(节选),可以作为TCP连接的典范:
bool CRemoteLink::Connect()
{
OnDisconnected(); // 如果已经连接，则断开
if(!m_bUseProxy)
{
m_iConnStatus = SS_CONNECTING; // 正在连接状态
GNTRACE ("开始连接到远程服务器[%s][%ld]...\n", m_strip.c_str(), m_port);
// 建立套接字, 准备连接到服务器
m_socket = ::socket(AF_INET, SOCK_STREAM, 0);
if (socket < 0) {
if(m_pCallBack)
m_pCallBack->OnSocketError(SE_CREATE, MSG_SE_CREATE);
return false;
}
// 设为异步操作方式
unsigned long on = 1;
if (::ioctlsocket(m_socket, FIONBIO, &on) < 0) {
::closesocket(m_socket);
if(m_pCallBack)
m_pCallBack->OnSocketError(SE_CREATE, MSG_SE_CREATE);
return false;
}
sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(m_strip.c_str());
addr.sin_port = htons(m_port);
int rt;
rt = ::connect(m_socket, (sockaddr *) &addr, sizeof(addr));
if (rt == 0) {
OnConnected();
return true;
}
// ==================================================================
timeval to;
// 首先建立连接
fd_set wfds;
fd_set efds;
FD_ZERO(&wfds);
FD_ZERO(&efds);
// test shutdown event each 100ms.
to.tv_sec = 0;
// CONNECT_TIMEOUT;
to.tv_usec = 100000;
int it = 0;
while(!m_meShutdown.Wait(0) && !m_meConnStop.Wait(0))
{
FD_SET(m_socket, &wfds);
FD_SET(m_socket, &efds);
int n = select(m_socket + 1, NULL, &wfds, &efds, &to);
if (n > 0) {
if(FD_ISSET(m_socket, &wfds))
{
OnConnected();
return true;
}
else
{
//int err = ::WSAGetLastError();
//const char* msg = GetLastErrorMessage(err);
GNTRACE ("CRemoteLink::Connect : connection attempt failed!\n");
if(m_pCallBack)
m_pCallBack->OnSocketError(SE_CONN, MSG_SE_CONN);
break;
}
} else if (n < 0) { // Select Error
int err = ::WSAGetLastError();
const char* msg = GetLastErrorMessage(err);
GNTRACE ("CRemoteLink::Connect : Select Error.[%d] - %s\n", err, msg);
if(m_pCallBack)
m_pCallBack->OnSocketError(err, msg);
break;
}
else
{
it += 100;
if(it > 30000) // 连接超时 -- (30S)
{
GNTRACE ("CRemoteLink::Connect : Time out.\n");
if(m_pCallBack)
m_pCallBack->OnSocketError(SE_TIMEOUT, MSG_SE_TIMEOUT);
break;
}
}
}
if(m_meConnStop.Wait(0))
{
GNTRACE("连接过程进行时被取消。\n");
}
}
else
{
// 通过代理服务器连接
⑸ Linux下socket并发连接数怎么设置
并发socket连接数的多少决定于系统资源的多少，没有一个常值的．在实际开发或者linux系统管理中也会根据需配段要进行相应的设置．
1．一般来说每一个网络连接，都会败销建立相应的socket句柄，同时每个连接也会有标准输入输出等基本的文件文件句柄，而且每一个socket连接都是进行文件操作的，因此连接数决定于系统资源．
2．Linux上一般可以通过ulimit来进行相应的资源限制，默认能打开的文件描述符自己可以查看．如下图所示：
3．ulimit的命令格式：ulimit [-acdfHlmnpsStvw] [size]
参数说明：
-H 设置硬资源限制.
-S 设置软资源限制.
-a 显示当前所有的资源限制.
-c size:设置core文件的最大值.单位:blocks
-d size:设置数据段的最大值.单位:kbytes
-f size:设置创建文件的最大值.单位:blocks
-l size:设置在内存中锁定进程的最大值.单位:kbytes
-m size:设置可以使用的培枯誉常驻内存的最大值.单位:kbytes
-n size:设置内核可以同时打开的文件描述符的最大值.单位:n
-p size:设置管道缓冲区的最大值.单位:kbytes
-s size:设置堆栈的最大值.单位:kbytes
-t size:设置CPU使用时间的最大上限.单位:seconds
-v size:设置虚拟内存的最大值.单位:kbytes
-u <程序数目> 用户最多可开启的程序数目
⑹ socket超时什么意思
你好，这分为两种情况。
Socket.connect连接超时有二种情况：
1.由于网络的问题，TCP/IP三次握手时间>timeout的设置时间。这在国外访问weibo时，并且网络环境极差的情况下有可能发生。
解决的办法：调大socket.connect方法中的timeout参数值，比如50s，linux默认最高是70s，如果超过70s没有意义，linux会采用70s.
但是当调大之后，发现不到10s就报timeout exception。
通过国外的机器ping api.weibo.com发现unreachable。
说明客户端在传输层之下的网络层就发现连个Syn的报文都发不出去，更不用说三次握手了，客户端直接失败并抛timeout exception。
经验：在connection timeout诊断的第一步应该是ping一下确认网络层没有问题。
注：客户端设置了timeout，但并不会等到超时才返回异常。客户端只要第一时间发现连接失败，就会抛timeout exception。
2.如果timeout设置的时间足够，但是由于服务器端的处理能力较差，比如缓冲连接队列较小，而应用层的处理能力没有连接缓冲快，导致缓冲连接占满，而拒绝新的连接。
在服务端因为连接队列占满而拒绝服务的期间，客户端的通过TCP协议重试三次。每次的时间翻倍。
如果三次时间的累加<timeout参数值且能连接上，属于正常情况，表示队列腾出空位放当前连接。
如果三次时间的累加<timeout参数值且未能连接上，则客户端会立刻抛出timeout exception,而不等timeout到期才抛。
1.读写超时
read超时设置有意义,在服务器处理能力差，但最终会响应的情况下，可以将客户端的等待响应时间设长一些。如果太长的话，由于客户端使用的是BIO的方式，线程会一直阻塞在IO而导致挂起。当客户端的处理能力明显快于服务端，这样挂起的线程会很多。
不管客户端还是服务器端，当有很多线程阻塞时，对机器的性能都会影响。我在weibo的论坛上看到有人在read timed out后，将soTimeout的时间设为100s。这是很危险的，新浪的服务器一旦崩溃，自己的服务器也会由于大量线程积压崩溃。
因为线程在挂起之后，它掌握的资源并不会释放，比如内存，直到阻塞完成。同时大量线程的挂起就意味着系统要做大量上下文的恢复并调度执行。
解决办法：
如果客户端使用NIO的方式，如果服务端的响应能标出客户端的请求，则线程在客户端请求之后，完全可以把请求放入一个BlockQueue，然后利用Future或Wait/Notify等机制在带着请求标志的响应返回的时候，唤想队列中的请求接着处理，从而实现异步处理，可以用少量线程服务大量请求。
同样，如果服务器端可以使用NIO做到请求每线程处理，而不是连接每线程，可以大大减少线程挂起导致资源的浪费，NIO适用于连接很多，请求很少的场合。另外，Commet又称为服务器推技术，它的主要特点是长连接。避免客户端低效的请求轮询。主要用于聊天室，WEIBO，因为连接多，请求不一定多，同样也适合在服务器端使用NIO
注：read timeout异常时，并不需要ping远程机器，因为它是辅助定位connection timeout，如果ping不通，肯定是conneciton timeout而不会到read timeout。read timeout exception不会导致连接中断。为重试提供了机会。
2.write超时一般不象connection timeout和read timeout可以在客户端显示调值，TCP有写重传的概念，一般8m内会重试，否则，直接断开连接。
如果对您有帮助，还望采纳。
⑺ linuxsocket阻塞如何退出
设置套接字为非阻塞模式。
1、通过设置套接字的属性，把其从阻塞模式改为非阻塞模式，即使没有数据凳喊到来或者连接建立，程序也不会一直等待，而是立刻返回。
2、裤碰超时机制：在代码中设置超时机制，即如果套接字在指定时间内依然处于阻塞状态，则退出程序。
3、信号处理：使用信号处理机制，在另一个线程中枣纯野发送一个指定的信号，如SIGINT信号，当程序接收到该信号时，可以退出当前的阻塞状态。
⑻ Linux如何清空Socket缓冲区
socket不是这么接收数据的 由于socket是以数据流的形式发送数据，接收方不知道对方一次性发送了多少数据，也能保证对方一次性发送的数据能在同一刻接收到，所以Receive方法是这么工作的： 接受一个byye[]类型的参数作为缓冲区，在经过一定的时间后把接收到的数据填充到这个缓冲区里面，并且返回实际接收到数据的长度，这个实际接收到的数据长度有可能为0（没有接收到数据）、大于0小于缓冲区的长度（接收到数据，但是没有我们预期的多）、等于缓冲区的长度（说明接收到的数据大于等于我们预期的长度）。 每次接收缓冲区都用同一个byte[] byteMessage，并且你没有检查接收到的数据长度，所以第一次你接收到的数据是123456，第二次你只接收到了8，但是缓冲区里面还有23456，所以加起来就是823456了。 socket接收缓冲区的大小有讲究，设置大了接收起来慢，因为它要等尽可能多的数据接收到了再返回；设置小了需要重复多次调用接收方法才能把数据接收完，socket有个属性，标识了系统默认的接收缓冲区大小，可以参考这个！ 还有就是用recv读取，但是由于不知道缓存里有多少数据，如果是阻塞模式，到最后必然等到超时才知道数据已经读取完毕，这是个问题。 另一个是用fgetc，通过返回判断是否是feof： whlie （1） { a=fgetc（f）；if （feof（f）） break；//… b=fgetc（f）；if （feof（f）） break；//…}当然，我不知道读取完毕后最后一次调用fgetc会不会堵塞，需要测试。 在非阻塞模式下，我们用recv就可以轻松搞定了，但是阻塞模式下，由于我们不知道缓冲区有多少数据，不能直接调用recv尝试清除。 使用一个小小的技巧，利用select函数，我们可以轻松搞定这个问题： select函数用于监视一个文件描述符集合，如果集合中的描述符没有变化，则一直阻塞在这里，直到超时时间到达；在超时时间内，一旦某个描述符触发了你所关心的事件，select立即返回，通过检索文件描述符集合处理相应事件；select函数出错则返回小于零的值，如果有事件触发，则返回触发事件的描述符个数；如果超时，返回0，即没有数据可读。 重点在于：我们可以用select的超时特性，将超时时间设置为0，通过检测select的返回值，就可以判断缓冲是否被清空。通过这个技巧，使一个阻塞的socket成了‘非阻塞’socket. 现在就可以得出解决方案了：使用select函数来监视要清空的socket描述符，并把超时时间设置为0，每次读取一个字节然后丢弃（或者按照业务需要进行处理，随你便了），一旦select返回0，说明缓冲区没数据了（“超时”了）。 struct timeval tmOut；tmOut.tv_sec = 0；tmOut.tv_usec = 0；fd_set fds；FD_ZEROS（&fds）；FD_SET（skt， &fds）； int nRet； char tmp[2]； memset（tmp， 0， sizeof（tmp））； while（1） { nRet= select（FD_SETSIZE， &fds， NULL， NULL， &tmOut）；if（nRet== 0） break；recv（skt， tmp， 1，0）；} 这种方式的好处是，不再需要用recv、recvfrom等阻塞函数直接去读取，而是使用select，利用其超时特性检测缓冲区是否为空来判断是否有数据，有数据时才调用recv进行清除。 有人说同样可以用recv和socket的超时设置去清空啊，这个没错，但是你需要直接对socket描述符设置超时时间，而为了清空数据而直接修改socket描述符的属性，可能会影响到其他地方的使用，造成系统奇奇怪怪的问题，所以，不推荐使用。
⑼ linux socket阻塞recv怎么返回
recv是socket编程中最常用的函数之一，在阻塞状态的recv有时候会返回不同的值，而对于错误值也有相应的错误码，分别对应不同的状态，下面是我针对常见的几种网络状态的简单总结。
首先阻塞接收的recv有时候会返回0，这仅在对端已经关闭TCP连接时才会发生。
而当拔掉设备网线的时候，recv并不会发生变化，仍然阻塞，如果在这个拔网线阶段，socket被关掉了，后果可能就是recv永久的阻塞了。
所以一般对于阻塞的socket都会用setsockopt来设置recv超时。
当超时时间到达后，recv会返回错误，也就是-1，而此时的错误码是EAGAIN或者EWOULDBLOCK，POSIX.1-2001上允许两个任意一个出现都行，所以建议在判断错误码上两个都写上。
如果socket是被对方用linger为0的形式关掉，也就是直接发RST的方式关闭的时候，recv也会返回错误，错误码是ENOENT
还有一种经常在代码中常见的错误码，那就是EINTER，意思是系统在接收的时候因为收到其他中断信号而被迫返回，不算socket故障，应该继续接收。但是这种情况非常难再现，我尝试过一边一直在不停的发信号，一边用recv接收数据，也没有出现过。这种异常错误我附近只有一个朋友在用write的时候见到过一次，但是总是会有概率出现的，所以作为完善的程序必须对此错误进行特殊处理。
一般设置超时的阻塞recv常用的方法都如下：
while(1)
{
cnt = (int)recv(m_socket, pBuf,RECVSIZE, 0);
if( cnt >0 )
{
//正常处理数据
}
else
{
if((cnt<0) &&(errno == EAGAIN||errno == EWOULDBLOCK||errno == EINTR)) //这几种错误码，认为连接是正常的，继续接收
{
continue;//继续接收数据
}
break;//跳出接收循环
}
}
阻塞与非阻塞recv返回值没有区分，都是 <0 出错 =0 连接关闭 >0 接收到数据大小。
Linux环境下，须如下定义：struct timeval timeout = {3,0};
//设置发送超时
setsockopt(socket，SOL_SOCKET,SO_SNDTIMEO，(char *)&timeout,sizeof(struct timeval));
//设置接收超时
setsockopt(socket，SOL_SOCKET,SO_RCVTIMEO，(char *)&timeout,sizeof(struct timeval));
⑽ linux下setsockopt设置socket超时
she would watch a show and buy some gifts.