linux tcp select 超时 自查文档

最新推荐文章于 2024-06-29 22:25:40 发布
最新推荐文章于 2024-06-29 22:25:40 发布
阅读量3.8k 收藏 1
点赞数
分类专栏： linux socket c 文章标签： linux tcp select
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzhuchen/article/details/51455352
版权
c 同时被 3 个专栏收录
34 篇文章 0 订阅
订阅专栏
linux
12 篇文章 0 订阅
订阅专栏
socket
2 篇文章 0 订阅
订阅专栏

tcp.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <fcntl.h>
#include <errno.h>



#include <linux/tcp.h>
#include <time.h>


#include "tcp.h"

/*
FD_ZERO(fd_set *fdset) 将指定的文件描述符集清空，在对文件描述符集合进行设置前，必须对其进行初始化，如果不清空，由于在系统分配内存空间后，通常并不作清空处理，所以结果是不可知的。
    FD_SET(fd_set *fdset) 用于在文件描述符集合中增加一个新的文件描述符。
    FD_CLR(fd_set *fdset) 用于在文件描述符集合中删除一个文件描述符。
    FD_ISSET(int fd,fd_set *fdset) 用于测试指定的文件描述符是否在该集合中
*/


int select_fd_init(fd_set *fdset)
{
    FD_ZERO(fdset);
    return 0;
}

int select_fd_del(fd_set *fdset, int fd)
{
    FD_CLR(fd, fdset);
    return 0;
}

int select_fd_add(fd_set *fdset, int fd)
{
    FD_SET(fd, fdset);
    return 0;
}
//在集合中返回<0出错，>0可读写，＝＝0超时
int select_fd_check_r(fd_set *fdset_r, int fd, int sec, int usec)
{
    /*
    返回值：返回状态发生变化的描述符总数。 
负值：select错误

正值：某些文件可读写或出错

0：等待超时，没有可读写或错误的文件
    */
    struct timeval ptv;
    int ret;

    ptv.tv_sec = sec;
    ptv.tv_usec = usec;
    ret = select(fd + 1, fdset_r, NULL, NULL, &ptv);
    if(ret < 0){
        return -1;
    }else if(ret > 0){
        return 1;
    }
    return 0;
}
//在集合中返回<0出错，>0可读写，＝＝0超时
int select_fd_check_w(fd_set *fdset_w, int fd, int sec, int usec)
{
    /*
    返回值：返回状态发生变化的描述符总数。 
负值：select错误

正值：某些文件可读写或出错

0：等待超时，没有可读写或错误的文件
    */
    struct timeval ptv;
    int ret;

    ptv.tv_sec = sec;
    ptv.tv_usec = usec;
    ret = select(fd + 1, NULL, fdset_w, NULL, &ptv);
    if(ret < 0){
        return -1;
    }else if(ret > 0){
        return 1;
    }
    return 0;
}
//在集合中返回<0出错，>0可读写，＝＝0超时
int select_fd_check_rw(fd_set *fdset_r, fd_set *fdset_w, int fd, int sec, int usec)
{
    /*
    返回值：返回状态发生变化的描述符总数。 
负值：select错误

正值：某些文件可读写或出错

0：等待超时，没有可读写或错误的文件
    */
    struct timeval ptv;
    int ret;

    ptv.tv_sec = sec;
    ptv.tv_usec = usec;
    ret = select(fd + 1, fdset_r, fdset_w, NULL, &ptv);
    if(ret < 0){
        return -1;
    }else if(ret > 0){
        return 1;
    }
    return 0;
}
//当描述符fd在描述符集fdset中返回非零值，否则，返回零。
int select_fd_check2(fd_set *fdset, int fd)
{
    return FD_ISSET(fd, fdset);
}
    /*
    返回值：返回状态发生变化的描述符总数。 
负值：select错误

正值：某些文件可读写或出错

0：等待超时，没有可读写或错误的文件
    */
int select_fd_timeout_r(int fd, int sec, int usec)
{
    struct timeval ptv;
    fd_set fdset;
    int ret;

    ptv.tv_sec = sec;
    ptv.tv_usec = usec;
    FD_ZERO(&fdset);
    FD_SET(fd, &fdset);
    ret = select(fd + 1, &fdset, NULL, NULL, &ptv);
    if(ret < 0){
        return -1;
    }else if(ret > 0){
        return 1;
    }
    return 0;
}
int select_fd_timeout_w(int fd, int sec, int usec)
{
    struct timeval ptv;
    fd_set fdset;
    int ret;

    ptv.tv_sec = sec;
    ptv.tv_usec = usec;
    FD_ZERO(&fdset);
    FD_SET(fd, &fdset);
    ret = select(fd + 1, NULL, &fdset, NULL, &ptv);
    if(ret < 0){
        return -1;
    }else if(ret > 0){
        return 1;
    }
    return 0;
}
int select_fd_timeout_rw(int fd, int sec, int usec)
{
    struct timeval ptv;
    fd_set fdset;
    int ret;

    ptv.tv_sec = sec;
    ptv.tv_usec = usec;
    FD_ZERO(&fdset);
    FD_SET(fd, &fdset);
    ret = select(fd + 1, &fdset, &fdset, NULL, &ptv);
    if(ret < 0){
        return -1;
    }else if(ret > 0){
        return 1;
    }
    return 0;
}
/*
在阻塞模式下, send函数的过程是将应用程序请求发送的数据拷贝到发送缓存中发送就返回.但由于发送缓存的存在,
表现为:如果发送缓存大小比请求发送的大小要大,那么send函数立即返回,同时向网络中发送数据;
否则,send会等待接收端对之前发送数据的确认,以便腾出缓存空间容纳新的待发送数据,
再返回(接收端协议栈只要将数据收到接收缓存中,就会确认,并不一定要等待应用程序调用recv),如果一直没有空间能容纳待发送的数据,则一直阻塞;
在非阻塞模式下,send函数的过程仅仅是将数据拷贝到协议栈的缓存区而已,如果缓存区可用空间不够,则尽能力的拷贝,立即返回成功拷贝的大小;如缓存区可用空间为0,则返回-1,同时设置errno为EAGAIN.


阻塞就是干不完不准回来，非阻塞就是你先干，我现看看有其他事没有，完了告诉我一声。
*/


int CloseSocket(int sockfd)
{
    shutdown(sockfd, 2);

    close(sockfd);
    sockfd = INVALID_SOCKET;

    return (0);
}



int Writen(int sckid, unsigned char *buf, int len, int sec, int usec)
{
    struct timeval ptv = {0,0}; 
    ptv.tv_sec = sec;
    ptv.tv_usec = usec;
    //设置发送超时
    setsockopt(sckid, SOL_SOCKET,SO_SNDTIMEO, (char *)&ptv,sizeof(struct timeval));

    if (send(sckid, buf, len, 0) != len)
    {
        return (-1);
    }
    return (len);
}

int Readn(int sckid, char *buf, int len, int sec, int usec)
{
    int rc = 0;
    struct timeval ptv = {0,0}; 
    ptv.tv_sec = sec;
    ptv.tv_usec = usec;

    //设置接收超时
    setsockopt(sckid, SOL_SOCKET,SO_RCVTIMEO, (char *)&ptv,sizeof(struct timeval));
    if ((rc = recv(sckid, buf, len, 0)) <= 0)
    {
        return (-1);
    }
    return (rc);
}


int ConnectRemote(char *ip, int port, int sec, int usec)
{
    struct sockaddr_in psckadd;
    struct linger Linger;

    int sckcli;
    int on = 1;

    struct timeval ptv;

    memset((char *)(&psckadd), '0', sizeof(struct sockaddr_in));
    psckadd.sin_family = AF_INET;
    psckadd.sin_addr.s_addr = inet_addr(ip);
    psckadd.sin_port = htons((u_short) port);

    if ((sckcli = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
    {
        return (INVALID_SOCKET);
    }



    //设置连接超时时间
    ptv.tv_sec = sec;
    ptv.tv_usec = usec; 
    if (setsockopt(sckcli, SOL_SOCKET, SO_SNDTIMEO, &ptv, sizeof(ptv)))
    {
        close(sckcli);
        return (INVALID_SOCKET);
    }   



    if (connect(sckcli, (struct sockaddr *)(&psckadd), sizeof(struct sockaddr_in)) < 0)
    {
        close(sckcli);
        return (INVALID_SOCKET);
    }

    //设置接收tcp外带数据
    if (setsockopt(sckcli, SOL_SOCKET, SO_OOBINLINE, (char *)&on, sizeof(on)))
    {
        CloseSocket(sckcli);
        return (INVALID_SOCKET);
    } 

    on = 1;
    setsockopt(sckcli, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof(on));

    /*
    TCP_NODELAY和TCP_CORK都是禁用Nagle算法，只不过NODELAY完全关闭算法，立即发送而TCP_CORK完全由自己决定发送时机
    */
    setsockopt(sckcli, IPPROTO_TCP, TCP_NODELAY, (void *)&on, sizeof(on));

    return (sckcli);
}


int ListenRemote(int port)
{
    int yes=1;
    int server_socket = INVALID_SOCKET;
    struct sockaddr_in server_addr;

    //创建套接字
    if((server_socket=socket(AF_INET,SOCK_STREAM,0))<0){
        return INVALID_SOCKET;
    }

    //设置为可重复使用
    if(setsockopt(server_socket,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int))==-1){
        close(server_socket);
        return INVALID_SOCKET;
    }
    //设置服务器地址信息设置
    server_addr.sin_family=AF_INET;                    //TCP
    server_addr.sin_port=htons(port);
    server_addr.sin_addr.s_addr=INADDR_ANY;            //本地IP地址

    memset(server_addr.sin_zero, 0,sizeof(server_addr.sin_zero));

    //绑定套接字与地址信息
    if(bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr))==-1){
        close(server_socket);
        return INVALID_SOCKET;
    }

    //侦听
    if(listen(server_socket,5)==-1){
        close(server_socket);
        return INVALID_SOCKET;
    }

    return server_socket;
}

int AcceptRemote(int sockfd)
{
    int client_sockfd = INVALID_SOCKET;//客户端套接字  
    struct sockaddr_in remote_addr; //客户端网络地址结构体  

    int sin_size=sizeof(struct sockaddr_in);  

    /*等待客户端连接请求到达*/  
    if((client_sockfd=accept(sockfd,(struct sockaddr *)&remote_addr,&sin_size))<0)  
    {  
        return INVALID_SOCKET;  
    } 

    //默认为阻塞模式

    return client_sockfd;
}


void setOpetinNoBlock(int fd)
{
    //设置为非阻塞模式
    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK); 

}

/*

int socket_recv(int sockfd, char* buffer, int buflen)
{
    int rs=1;
    int ret;
    while(rs)
    {
        ret = recv(activeevents[i].data.fd, buffer, buflen, 0);
        if(ret < 0)
        {
            // 由于是非阻塞的模式,所以当errno为EAGAIN时,表示当前缓冲区已无数据可读
            // 在这里就当作是该次事件已处理处.
            if(errno == EAGAIN)
                break;

        }
        else if(ret == 0)
        {
            // 这里表示对端的socket已正常关闭.
            break;
        }
        if(buflen == ret)
            rs = 1;   // 需要再次读取
        else
            rs = 0;
    }

    return ret;

}



int socket_send(int sockfd, const char* buffer, int buflen)
{
    int tmp;
    int total = buflen;
    const char *p = buffer;

    while(1)
    {
        tmp = send(sockfd, p, total, 0);
        if(tmp < 0)
        {
            // 当send收到信号时,可以继续写,但这里返回-1.
            if(errno == EINTR)
            return -1;

            // 当socket是非阻塞时,如返回此错误,表示写缓冲队列已满,
            // 在这里做延时后再重试.
            if(errno == EAGAIN)
            {
                usleep(1000);
                continue;
            }

            return -1;
        }

        if((size_t)tmp == total)
            return buflen;

        total -= tmp;
        p += tmp;
    }

    return tmp;
}


*/

tcp.h



#define INVALID_SOCKET -1




int select_fd_init(fd_set *fdset);
int select_fd_del(fd_set *fdset, int fd);
int select_fd_add(fd_set *fdset, int fd);
int select_fd_check_r(fd_set *fdset_r, int fd, int sec, int usec);
int select_fd_check_w(fd_set *fdset_w, int fd, int sec, int usec);
int select_fd_check_rw(fd_set *fdset_r, fd_set *fdset_w,int fd, int sec, int usec);

int select_fd_check2(fd_set *fdset, int fd);
int select_fd_timeout_r(int fd, int sec, int usec);
int select_fd_timeout_w(int fd, int sec, int usec);
int select_fd_timeout_rw(int fd, int sec, int usec);

int CloseSocket(int sockfd);

int Writen(int sckid, unsigned char *buf, int len, int sec, int usec);
int Readn(int sckid, char *buf, int len, int sec, int usec);
int ConnectRemote(char *ip, int port, int sec, int usec);
int ListenRemote(int port);
int AcceptRemote(int sockfd);
void setOpetinNoBlock(int fd);

server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <pthread.h>

#include "tcp.h"


void* work(void* arg)
{
    int sckcli = *(int*) arg;
    char buff[1024];
    int ret;



    ret = Readn( sckcli, buff, 1024, 3, 0);
    if(ret < 0){
        printf("read error\n");
            close(sckcli);
        return NULL;
    }else{
        buff[ret]='\0';
        printf("received:%s\n", buff);          
    }


    ret = Writen(sckcli, buff, ret, 3, 0);
    if(ret < 0){
        printf("write error\n");
    }
    close(sckcli);

}



void* accpet_work(void* arg)
{
    int sckcli;
    int sckser = *(int *)arg;
    pthread_t       tid; 
    pthread_attr_t  attr; 
    fd_set fd;
    int ret;

    while(1)
    {

        ret = select_fd_timeout_r(sckser, 3, 0);
        if(ret <= 0){
            printf("1AcceptRemote ret  socket Accept错误errno = [%d] %d\n", errno, ret);
            continue;
        }  
        sckcli = AcceptRemote(sckser);
        if(INVALID_SOCKET == sckcli)
        {
            printf("2AcceptRemote ret  socket Accept错误errno = [%d]\n", errno);
            usleep(1);
            continue;
        }
        pthread_attr_init(&attr); 
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 
        pthread_create(&tid, &attr, work, &sckcli);

    }

}

/* 
    pthread_t       tid; 
    pthread_attr_t  attr; 
    pthread_attr_init(&attr); 
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 
    pthread_create(&tid, &attr, THREAD_FUNCTION, arg); 
    */


int main(int rgvs, char **rgva)
{

    int ret;
    int len;
    int sckser1;
    int sckser2;

    int i=0;
    char buff[1024];

    if(rgvs <3){
        printf("%s <listen port port>\n", rgva[0]);
        return 0;       
    }


    pthread_t       tid1; 
    pthread_t       tid2; 
    pthread_attr_t  attr; 

    sckser1 = ListenRemote(atoi(rgva[1]));
    if(sckser1 >0){
        setOpetinNoBlock(sckser1);
        pthread_create(&tid1, NULL, accpet_work, &sckser1); 
    }
    sckser2 = ListenRemote(atoi(rgva[2]));
    if(sckser2 > 0){
        setOpetinNoBlock(sckser2);  
        pthread_create(&tid2, NULL, accpet_work, &sckser2);
    }

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);




    close(sckser1);
    close(sckser2);


}

client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "tcp.h"


int main(int rgvs, char **rgva)
{

    int ret;
    int len;
    int sckcli;
    int i=0;
    char buff[1024];
    if(rgvs <4){
        printf("%s <destip> <destport> <conect time>\n", rgva[0]);
        return 0;       
    }


    for(i=0;i<atoi(rgva[3]); i++)
    {
        sckcli = ConnectRemote(rgva[1], atoi(rgva[2]), 10, 0);
        if(INVALID_SOCKET == sckcli)
        {
            printf("%s conect %s %s error \n", rgva[0], rgva[1], rgva[2]);
            return 0;
        }           
        sprintf(buff, "%d",i);
        printf("Enter string to send: %s\n", buff);

        len=Writen(sckcli,buff,strlen(buff),10, 0);
        len=Readn(sckcli,buff,BUFSIZ,10, 0);
        if(len < 0){
            printf("read error\n");
        }else{
            buff[len]='\0';
            printf("received:%s\n", buff);          
        }

        close(sckcli);          
    }



    return 0;

}

引用：
http://blog.csdn.net/hguisu/article/details/7453390

Brickie-liu
关注
专栏目录
linux socket select(tcp)
lpaim的博客
01-23 2941
linux socket select(tcp)
linux下c程序超时,七、TCP C/S：socket 读写超时设置
weixin_39590453的博客
05-03 1102
我们可以通过设置 socket 选项 SO_SNDTIMEO 和 SO_RCVTIMEO 来减少读写 socket 的等待时间。1. 程序源码在创建 socket 后，通过 setsockopt 函数修改读写超时时间即可。测试时只修改客户端 socket 的超时。clientint main(int argc, char **argv){struct timeval tv;/** 省略*...
socket select（）用法
03-05
网上搜索的，略加整理。
socket select 超时设置/select 集合
liuzhuchen的专栏
05-04 2337
socket select 超时设置
Linux-select同时监听读写-ulimit-select的原理-select的调用流程-select设置超时；
最新发布
weixin_63494444的博客
06-29 1064
mmap实现的细节与 DMA 的使用是分开的。当通过mmap访问映射的文件或设备时，数据可能通过传统的 I/O 路径（涉及 CPU、内存和 I/O 控制器）进行传输，也可能在某些情况下使用 DMA 来优化性能。但是，这种优化是由操作系统和硬件共同决定的，而不是由mmap系统调用直接控制的。DMA（Direct Memory Access），即直接存储器访问，是一种在计算机系统中允许某些硬件子系统与主存储器（RAM）进行直接数据传输的技术，而无需通过中央处理器（CPU）的干预。
Socket超时设置---select()的妙用
热门推荐
cation的专栏
05-03 2万+
http://fanqiang.chinaunix.net/a4/b7/20010913/0900001283.html【 原文由 cpu 所发表 】  用过 WinSock API 网友们知道：WinSock 编程中有一很方便的地方便是其 息驱动机制，不管是底层 API 的 WSAAsyncSelect() 还是 MFC 的异步Socket类： CAsyncSocket，都提供了诸如 FD_AC
基于select实现socket的超时功能
weixin_44269491的博客
09-18 437
今天遇到一个要求，套接字连上之后，由于在recv数据时就阻塞住了，一般会要求等待5s之后假如超时就返回失败，通过select实现了一下要求： #define BUF_SIZE 128 #define RESPONSE_TIMEOUT 5 int ReciveResponse(int sfd, void *out_receive_data, int receive_data_size) { if (!out_receive_data || receive_data_size == 0) {
php socket_select超时,php – 正确使用socket_select()
weixin_31834087的博客
03-17 211
在PHP中使用socket_select发送和接收数据的正确方法是什么？我有一个连接到服务器,允许TCP和amp; UDP数据包连接,我正在利用它们.在这些连接中,我在同一端口上发送和接收数据包,但TCP数据包将在一个端口(29999)上发送,UDP将在另一个端口(30000)上发送.传输类型将是AF_INET的传输类型. IP地址将是环回127.0.0.1.有可能不会从服务器向客户端发送任何数据...
linux connect 超时时间,Linux下connect超时处理【总结】
weixin_28764661的博客
05-08 2321
1、前言最近在写一个测试工具，要求快速的高效率的扫描出各个服务器开放了哪些端口。当时想了一下，ping只能检测ip，判断服务器的网络是连通的，而不能判断是否开放了端口。我们知道端口属于网络的应用层，因此需要用ip和端口来探测，这个时候就可以用connect来探测一下，针对TCP协议，connect函数要进行TCP三次握手，如果connect成功，则说明服务器开放了某个端口，如果connect失败，...
Linux 下使用select 实现TCP server和TCP client
whuer_xiaojie的博客
03-28 3215
基于TCP（面向链接）的socket编程 Server端的流程如下： 1 创建Socket套接字 2 将套接字绑定到一个本地地址（IP）和端口（port）上 3 将套接字设置为监听模式，准备接收客户端请求（listen） 4 等待客户端请求，当请求到来后，接受链接请求，返回一个新的对应于此次链接的套接字（accept） 5 用返回的套接字和客户端进行通信（send/recv ...
linux socket默认超时时间设置,linux下socket connect超时设置
weixin_36179469的博客
05-01 4907
今天发现自己的系统存在很严重缺陷，当前台关闭的时候后台就无法正常工作，原因很好定位，后台的socket连接超时时间过长，系统默认时间好像是75秒，于是找资料，根据下边文章中的内容解决了，把超时时间设为5秒后，感觉好多了。看来还有好多东西需要慢慢挖掘阿！如何设置socket的Connect超时(linux)[From]http://dev.cbw.com/c/c/200510195601_42925...
SELECT超时小结
wangluozhangleilei的专栏
07-19 2106
目前各平台通用的设置socket connect超时的办法是通过select()，具体方法如下 1.建立socket； 2.将该socket设置为非阻塞模式； 3.调用connect()； 4.使用select()检查该socket描述符是否可写； 5.根据select()返回的结果判断connect()结果； 6.将socket设回阻塞模式。
TCP/UDP select超时处理
ljd_1986413的专栏
09-06 2022
///////////超时接收处理   int nfound,maxfd=0;   fd_set rset,set;   maxfd = fileno(stdin);  FD_ZERO(&set);//清空套接字集合  FD_SET(sock1,&set);//将sock加入set集合  FD_SET(maxfd,&set);//将maxfd加入set集合  maxfd=(maxfd
Windows Linux 跨平台简单tcp实现 基于设置socket非阻塞，select连接超时控制。
huangtianyi1994的博客
07-20 338
#ifdef WIN32 #pragma once #ifdef XSOCKET_EXPORTS #define XSOCKET_API __declspec(dllexport) #else #define XSOCKET_API __declspec(dllimport) #endif #else #define XSOCKET_API #endif // WIN32 //tcp封装 在windows下封装成dll 在linux下封装成.so #include<string> ...
select实现socket_connect_timeout
weixin_43899266的博客
04-14 264
int socket_connect_timeout(char *host, int port, long timeout){ int sockfd; struct sockaddr_in server; server.sin_family = AF_INTE; server.sin_port = htons(port); server.sin_addr.s_addr = ...
IO多路复用（select）实现TCP并发服务器-使用select函数实现超时检测-传输层
qq_47355554的博客
05-23 551
目录使用select函数实现超时检测网络超时检测概念select代码实现服务器—01server.c客户端—02client.c执行结果6.非原创 使用select函数实现超时检测 网络超时检测概念 阻塞： 以读阻塞为例，如果缓冲区中有内容，则程序正常执行 如果缓冲区没有内容，程序会一直阻塞，直到有内容，读取内容继续向下运行。 非阻塞 ： 以读阻塞为例，如果缓冲区中有内容，则程序正常执行 如果缓冲区没有内容，程序会立即返回，然后继续向下运行。 超时检测： 介于阻塞和非阻塞之间，需要设置一定的时间，
[转]socket超时设置详解(connect/read/write)
weixin_30414635的博客
12-28 486
https://blog.csdn.net/gettogetto/article/details/77105005 一.基本概念(摘自：《unix网络编程》卷114.2 套接字超时)在涉及套接字的I/O操作上设置超时的方法有以下三种(1)调用alarm，它在指定超时期满时产生SIGALARM。这个方法涉及信号处理，而信号处理在不同的实现上存在差异，而且可能干扰进程中现有的alarm调...
TCP 网络超时 select 及 recv 实现
Turbyun的博客
08-28 2252
fd_set set; struct timeval st_time; st_time.tv_sec = 3 * 3; st_time.tv_usec = 0; while (1) { strcpy(sendbuf, "hello every"); FD_ZERO(&amp;set); ...
Linux TCP服务器：单进程多用户select实现详解
在Linux网络编程中，本文档介绍了一种基于TCP协议的服务器设计，采用单进程多用户模型，特别地，它使用了`select()`函数来处理并发连接。标题为"TCP服务器（单进程多用户）"，作者为sg131971@qq.com，该代码适用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Brickie-liu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值