C/S 超时控制的几种写法

最新推荐文章于 2022-08-19 16:28:05 发布
最新推荐文章于 2022-08-19 16:28:05 发布
阅读量1.2k 收藏 1
点赞数 2
分类专栏： 网络编程 文章标签： 网络编程 UNP Unix/Linux网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RGBMarco/article/details/79331602
版权

第一种:调用alarm(second)超时时,发送SIGALRM信号,产生中断.
实例:回显C/S

服务端代码:

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>
#include <signal.h>
#include <netdb.h>

#define BUFSIZE 4096
#define LISTENQ 100
void sig_child(int signo) {
    int ppid;
    while ((ppid = waitpid(-1,NULL,WNOHANG)) > 0) {
        printf("child: %d terminate\n",ppid);
    }
}
void sig_alarm(int signo) {
    return;
}
int tcp_send(int sockfd,char* buf,int len,int second) {
    struct sigaction oact,act;
    act.sa_handler = sig_alarm;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (sigaction(SIGALRM,&act,&oact) < 0) {
        printf("tcp_send: sigaction error: %s\n",strerror(errno));
        exit(1);
    }   
    if (alarm(second) != 0) {
        printf("tcp_send: already set alarm\n");
        exit(1);
    }

    if (write(sockfd,buf,len) != len) {
        if (errno == EINTR) {
            errno = ETIMEDOUT;
            printf("tcp_send: send message to client timeout\n");
            exit(1);
        }
        printf("write error: %s\n",strerror(errno));
        exit(1);
    }
    alarm(0);
    if (sigaction(SIGALRM,&oact,NULL) < 0) {
        printf("tcp_send: sigaction error: %s\n",strerror(errno));
        exit(1);
    }
}

void server_echo(int sockfd) {
    char recv[BUFSIZE];
    int n;
    while ((n = read(sockfd,recv,BUFSIZE)) > 0) {
        //sleep(8);
        tcp_send(sockfd,recv,n,2);
    }
}

int main(int argc,char** argv) {
    if (argc != 2) {
        printf("please add <service name or port number>\n");
        exit(1);
    }

    struct addrinfo hints;
    bzero(&hints,sizeof(struct addrinfo));

    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    struct addrinfo* results;
    int err;
    if ((err = getaddrinfo(NULL,argv[1],&hints,&results)) != 0) {
        printf("getaddrinfo error: %s\n",gai_strerror(err));
        exit(1);
    }

    struct addrinfo* dummy = results;
    int sockfd;
    for (; dummy != NULL; dummy = dummy->ai_next) {
        if ((sockfd = socket(dummy->ai_family,dummy->ai_socktype,dummy->ai_protocol)) < 0) {
            continue;
        }
        if (bind(sockfd,dummy->ai_addr,dummy->ai_addrlen) == 0) {
            break;
        }
        close(sockfd);
    }
    if (dummy == NULL) {
        freeaddrinfo(results);
        printf("all socket failed\n");
        exit(1);
    }
    freeaddrinfo(results);
    if (listen(sockfd,LISTENQ) < 0) {
        printf("listen error: %s\n",strerror(errno));
        exit(1);
    }
    if (signal(SIGCHLD,sig_child) == SIG_ERR) {
        printf("signal error: %s\n",strerror(errno));
        exit(1);
    }


    int connfd;
    int pid;
    for (; ;) {
        if ((connfd = accept(sockfd,NULL,NULL)) < 0) {
            if (errno == EINTR) {
                continue;
            }
            printf("accept error: %s\n",strerror(errno));
            exit(1);
        }
        if ((pid = fork()) < 0) {
            printf("fork error: %s\n",strerror(errno));
            exit(1);
        }else if (pid == 0) {
            close(sockfd);
            server_echo(connfd);
            close(connfd);
        }
        close(connfd);
    } 
    return 0;
}

客户端代码:

#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <signal.h>


#define BUFSIZE 4096

static void sig_alarm(int signo) {
    return;
}

int tcp_connect(int sockfd,struct sockaddr* peer,socklen_t len,int second) {
    //成功返回 1 失败返回-1 超时返回0
    int ret = 1;
    struct sigaction oact,act;
    act.sa_handler = sig_alarm;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (sigaction(SIGALRM,&act,&oact) < 0) {
        printf("tcp_connect: sigaction error: %s\n",strerror(errno));
        exit(1);
    }

    if (alarm(second) != 0) {
        printf("tcp_connect: alarm error: alarm already set\n");
        exit(1);
    }

    if (connect(sockfd,peer,len) < 0) {
        if (errno == EINTR) {
            errno = ETIMEDOUT;
            ret = 0;
            printf("tcp_connect: one connect timeout\n");
        }else {
            ret = -1;
        }
    }

    alarm(0);
    if (sigaction(SIGALRM,&oact,NULL) < 0) {
        printf("tcp_connect: sigaction error: %s\n",strerror(errno));
        exit(1);
    }
    return ret;
}

int tcp_recv(int sockfd,char* buf,int second) {
    struct sigaction oact,act;
    act.sa_handler = sig_alarm;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (sigaction(SIGALRM,&act,&oact) < 0) {
        printf("tcp_recv: sigaction error: %s\n",strerror(errno));
        exit(1);
    }
    if (alarm(second) != 0) {
        printf("tcp_recv: alarm error: alarm already set\n");
        exit(1);
    }
    int cread = -1;
    if ((cread = read(sockfd,buf,BUFSIZE)) < 0) {
        if (errno == EINTR) {
            errno = ETIMEDOUT;
            printf("tcp_recv: read error: recvive from server timeout\n");
        }else {
            printf("tcp_recv: read error: %s\n",strerror(errno));
            exit(1);
        }
    }

    alarm(0);
    if (sigaction(SIGALRM,&oact,NULL) < 0) {
        printf("tcp_recv: sigaction error: %s\n",strerror(errno));
        exit(1);
    }
    return cread;
}
int main(int argc,char** argv) {
    if (argc != 3) {
        printf("please add <ip address or host-name> <service name or port>\n");
        exit(1);
    }

    struct addrinfo hints;
    bzero(&hints,sizeof(struct addrinfo));

    hints.ai_flags = AI_ALL;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    struct addrinfo* results;
    int err;
    if ((err = getaddrinfo(argv[1],argv[2],&hints,&results)) != 0) {
        printf("getaddrinfo error: %s\n",gai_strerror(err));
        exit(1);
    }

    struct addrinfo* dummy = results;
    int sockfd;
    for (; dummy != NULL; dummy = dummy->ai_next) {
        if ((sockfd = socket(dummy->ai_family,dummy->ai_socktype,dummy->ai_protocol)) < 0) {
            continue;       
        }
        if (tcp_connect(sockfd,dummy->ai_addr,dummy->ai_addrlen,5) > 0) {
            break;
        }
        close(sockfd); 
    }
    if (dummy == NULL) {
        freeaddrinfo(results);
        printf("all connect failed\n");
        exit(1);
    }
    freeaddrinfo(results);
    char send[BUFSIZE];
    int n;
    while ((n = read(STDIN_FILENO,send,BUFSIZE)) > 0) {
        if (write(sockfd,send,n) != n) {
            printf("write error: %s\n",strerror(errno));
            exit(1);
        }
        if ((n = tcp_recv(sockfd,send,20)) == 0) {
            printf("server is restart or closed\n");
            exit(1);
        }
        if (write(STDIN_FILENO,send,n) != n) {
            printf("write error: %s\n",strerror(errno));
            exit(1);
        }   
    }
    return 0;
}

第二种:采用轮询技术:
select + udp echo c/s:
服务端代码:

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <unistd.h>

#define BUFSIZE 4096

int main(int argc,char** argv) {
    if (argc != 2) {
        printf("please check <service name or port>\n");
        exit(1);
    }

    struct addrinfo hints;
    bzero(&hints,sizeof(struct addrinfo));

    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_protocol = IPPROTO_UDP;

    struct addrinfo* results;
    int err;
    if ((err = getaddrinfo(NULL,argv[1],&hints,&results)) != 0) {
        printf("getaddrinfo error: %s\n",gai_strerror(errno));
        exit(1);
    }

    struct addrinfo* dummy = results;
    int sockfd;
    for (; dummy != NULL; dummy = dummy->ai_next) {
        if ((sockfd = socket(dummy->ai_family,dummy->ai_socktype,dummy->ai_protocol)) < 0) {
            continue;
        }
        if (bind(sockfd,dummy->ai_addr,dummy->ai_addrlen) == 0) {
            break;
        }
        close(sockfd);      
    }

    if (dummy == NULL) {
        freeaddrinfo(results);
        printf("all failed\n");
        exit(1);
    }

    freeaddrinfo(results);
    struct sockaddr_storage peer;
    char recv[BUFSIZE];
    socklen_t len = sizeof(struct sockaddr_storage);
    int n;
    for (; ;) {
        if ((n = recvfrom(sockfd,recv,BUFSIZE,0,(struct sockaddr*)&peer,&len)) < 0) {
            printf("recvfrom error: %s\n",strerror(errno));
            exit(1);
        }
        sleep(9);   
        if (sendto(sockfd,recv,n,0,(struct sockaddr*)&peer,len) != n) {
            printf("sendto error: %s\n",strerror(errno));
            exit(1);
        }
    }   
    return 0;
}

客户端代码:

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <sys/select.h>
#include <signal.h>


#define BUFSIZE 4096

void sig_alarm(int signo) {
    return;
}

int udp_readable(int fd,int second,int usec) {
    fd_set fs;
    FD_ZERO(&fs);
    FD_SET(fd,&fs);
    struct timeval tv;
    tv.tv_sec = second;
    tv.tv_usec = usec;
    return select(fd + 1,&fs,NULL,NULL,&tv);
}

void client(int fd) {
    char send[BUFSIZE];
    int n;
    int err;
    while ((n = read(STDIN_FILENO,send,BUFSIZE)) > 0) {
        if (write(fd,send,n) != n) {
            printf("write error: %s\n",strerror(errno));
            exit(1);
        }
        if ((err = udp_readable(fd,5,20)) == 0) {
            printf("udp_read: timeout\n");
            exit(1);
        }else if (err < 0) {
            printf("udp_read: select error\n");
            exit(1);
        }else if (err > 0) {
            if ((n = read(fd,send,BUFSIZE)) < 0) {
                printf("read error: %s\n",strerror(errno));
                exit(1);
            }
        }
        if (write(STDOUT_FILENO,send,n) != n) {
            printf("write error: %s\n",strerror(errno));
            exit(1);
        }
    }
}
int udp_connect(int sockfd,struct addrinfo* to,int second) {
    struct sigaction oact,act;
    act.sa_handler = sig_alarm;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (sigaction(SIGALRM,&act,&oact) < 0) {
        printf("udp_connect: sigaction error: %s\n",strerror(errno));
        exit(1);
    }
    if (alarm(second) != 0) {
        printf("udp_connect: alarm alreay set\n");
        exit(1);
    }
    int ret = 0;
    if (connect(sockfd,to->ai_addr,to->ai_addrlen) < 0) {
        if (errno == EINTR) {
            errno = ETIMEDOUT;
            printf("udp_connect: connect timeout\n");
            ret = 1;
        }else {
            printf("udp_connect: connect error: %s\n",strerror(errno));
            ret = -1;
        }
    }

    alarm(0);
    if (sigaction(SIGALRM,&oact,NULL) < 0) {
        printf("udp_connect:sigaction error: %s\n",strerror(errno));
        exit(1);
    }
    return ret;
}

int main(int argc,char** argv) {
    if (argc != 3) {
        printf("please check <hostname or ip address> <service name or port>\n");
        exit(1); 
    }

    struct addrinfo hints;
    bzero(&hints,sizeof(struct addrinfo));

    hints.ai_flags = AI_ALL;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_protocol = IPPROTO_UDP;

    struct addrinfo* results;
    int err;
    if ((err = getaddrinfo(argv[1],argv[2],&hints,&results)) != 0) {
        printf("getaddrinfo error: %s\n",gai_strerror(err));
        exit(1);
    }
    struct addrinfo* dummy = results;
    int sockfd;
    for (; dummy != NULL; dummy = dummy->ai_next) {
        if ((sockfd = socket(dummy->ai_family,dummy->ai_socktype,dummy->ai_protocol)) < 0) {
            continue;
        }
        if (udp_connect(sockfd,dummy,5) == 0) {
            break;
        }
        close(sockfd);
    }
    if (dummy == NULL) {
        printf("all socket failed\n");
        freeaddrinfo(results);
        exit(1);
    }
    client(sockfd);
    close(sockfd);
    return 0;
}

第三种:为套接字设置SO_RCVTIMEO或SO_SNDTIMEO选项
服务端代码:

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netdb.h>
#include <string.h>
#include <errno.h>
#include <netinet/sctp.h>

#define SCTP_MAX_STREAM 20
#define LISTENQ 100
#define BUFSIZE 4096

int main(int argc,char** argv) {
    if (argc != 2) {
        printf("please add <service name or port>\n");
        exit(1);
    }

    struct addrinfo hints;
    bzero(&hints,sizeof(struct addrinfo));

    hints.ai_flags = AI_PASSIVE;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_SEQPACKET;
    hints.ai_protocol = IPPROTO_SCTP;

    struct addrinfo* results;
    int err;
    if ((err = getaddrinfo(NULL,argv[1],&hints,&results)) != 0) {
        printf("getaddrinfo error: %s\n",gai_strerror(err));
        exit(1);
    }
    struct addrinfo* dummy = results;
    int sockfd;
    for (; dummy != NULL; dummy = dummy->ai_next) {
        if ((sockfd = socket(dummy->ai_family,dummy->ai_socktype,dummy->ai_protocol)) < 0) {
            continue;
        }
        if (bind(sockfd,dummy->ai_addr,dummy->ai_addrlen) == 0) {
            break;
        }
        close(sockfd);
    }
    if (listen(sockfd,LISTENQ) < 0) {
        printf("listen error: %s\n",strerror(errno));
        exit(1);
    }
    struct sctp_initmsg sim;
    bzero(&sim,sizeof(struct sctp_initmsg));
    sim.sinit_num_ostreams = SCTP_MAX_STREAM;
    if (setsockopt(sockfd,IPPROTO_SCTP,SCTP_INITMSG,&sim,sizeof(struct sctp_initmsg)) < 0) {
        printf("setsockopt error: %s\n",strerror(errno));
        exit(1);
    }
    struct sctp_event_subscribe events;
    bzero(&events,sizeof(struct sctp_event_subscribe));
    events.sctp_data_io_event = 1;
    if (setsockopt(sockfd,IPPROTO_SCTP,SCTP_EVENTS,&events,sizeof(struct sctp_event_subscribe)) < 0) {
        printf("setsockopt error: %s\n",strerror(errno));
        exit(1);
    }
    char recv[BUFSIZE];
    int n;
    struct sctp_sndrcvinfo sri;
    struct sockaddr_storage peer;
    socklen_t len = sizeof(struct sockaddr_storage);
    int msg_flags;
    int stream_no = 0;
    for (; ;) {
        if ((n = sctp_recvmsg(sockfd,recv,BUFSIZE,(struct sockaddr*)&peer,&len,&sri,&msg_flags)) < 0) {
            printf("sctp_recvmsg error: %s\n",strerror(errno));
            exit(1);
        }

        if (stream_no >= SCTP_MAX_STREAM) {
            stream_no = 0;
        }
        sleep(7);
        if (sctp_sendmsg(sockfd,recv,n,(struct sockaddr*)&peer,len,0,0,stream_no++,0,0) != n) {
            printf("sctp_sendmsg error: %s\n",strerror(errno));
            exit(1);
        }
    }
    return 0;
}

客户端代码:

#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <netinet/sctp.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>

#define BUFSIZE 4096
#define SCTP_MAX_STREAM 15

void client(int fd,struct sockaddr* to,socklen_t tolen) {
    char send[BUFSIZE];
    int n;
    struct sctp_sndrcvinfo sri;
    int stream_num = 0;
    int msg_flags;
    struct timeval tv;
    tv.tv_sec = 5;
    tv.tv_usec = 20;
    if (setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(struct timeval)) < 0) {
        printf("setsockopt error: %s\n",strerror(errno));
        exit(1);
    }   
    while ((n = read(STDIN_FILENO,send,BUFSIZE)) > 0) {
        if (stream_num >= SCTP_MAX_STREAM) {
            stream_num = 0;
        }
        if (sctp_sendmsg(fd,send,n,to,tolen,0,0,stream_num++,0,0) != n) {
            printf("sctp_sendmsg error: %s\n",strerror(errno));
            exit(1);
        }
        if ((n = sctp_recvmsg(fd,send,BUFSIZE,NULL,NULL,&sri,&msg_flags)) < 0) {
            if (errno == EWOULDBLOCK) {
                printf("sctp_recvmsg: timeout\n");
                exit(1);
            }else {
                printf("sctp_recvmsg error: %s\n",strerror(errno));
                exit(1);
            }
        }
        printf("server peer stream_num: %d sctp_assoc_id %d\n",sri.sinfo_stream,sri.sinfo_assoc_id);
        if (write(STDOUT_FILENO,send,n) != n) {
            printf("write error: %s\n",strerror(errno));
            exit(1);
        }
    }
}
int main(int argc,char** argv) {
    if (argc != 3) {
        printf("please check <host-name or ip address>\n");
        exit(1);
    }

    struct addrinfo hints;
    bzero(&hints,sizeof(struct addrinfo));

    hints.ai_flags = AI_ALL;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_SEQPACKET;
    hints.ai_protocol = IPPROTO_SCTP;

    struct addrinfo* results;
    int err;
    if (getaddrinfo(argv[1],argv[2],&hints,&results) != 0) {
        printf("getaddrinfo error: %s\n",gai_strerror(err));
        exit(1);
    }
    int sockfd;
    struct addrinfo* dummy = results;
    sctp_assoc_t id;
    for (; dummy != NULL; dummy = dummy->ai_next) {
        if ((sockfd = socket(dummy->ai_family,dummy->ai_socktype,dummy->ai_protocol)) < 0) {
            continue;
        }
        struct sctp_initmsg sim;
        bzero(&sim,sizeof(struct sctp_initmsg));
        sim.sinit_num_ostreams = SCTP_MAX_STREAM;
        if (setsockopt(sockfd,IPPROTO_SCTP,SCTP_INITMSG,&sim,sizeof(struct sctp_initmsg)) < 0) {
            close(sockfd);
            continue;
        }
        struct sctp_event_subscribe events;
        bzero(&events,sizeof(struct sctp_event_subscribe));
        events.sctp_data_io_event = 1;
        if (setsockopt(sockfd,IPPROTO_SCTP,SCTP_EVENTS,&events,sizeof(struct sctp_event_subscribe)) < 0) {
            close(sockfd);
            continue;
        }
        if (sctp_connectx(sockfd,dummy->ai_addr,1,&id) == 0) {
            break;
        }
        close(sockfd);
    }
    if (dummy == NULL) {
        freeaddrinfo(results);
        printf("all failed\n");
        exit(1);
    }
    client(sockfd,dummy->ai_addr,dummy->ai_addrlen);
    freeaddrinfo(results);
    close(sockfd);
    return 0;
}
RGBMarco
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/S模型安全登录解决方案
Shallway
12-22 2944
身为信息安全专业的，还是写点与专业相关的博文吧。。嗯。 一般在C/S软件中，登录流程都设计的很复杂，比如QQ。一方面为了防止伪造客户端，而另一方面更重要的则是对信息加密，防止明文被截取。 下面介绍一种比较好的解决方案。 首先，加密算法首当其中选RSA了（因为每门专业课都要考它。。），先简单介绍下RSA原理： RSA的安全性依赖于大数分解。公钥和私钥都是两个大素数（ 大于 100个十进制位）
c语言 read函数 超时,求助，关于c++ write及read函数的问题
weixin_36213934的博客
05-20 454
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include //#include #include #include using namespace std;class A{private:int a;std::string n;public:A(){}A(const int a1,const std::string n1){a=a1;n=n1;}A(A &x){a=x.a;n=x.n;...
对于网络超时C/S架构的应用如何处理才好？
netyou的专栏
04-10 252
目前在维护一个C/S应用,三层架构,对于网络稍微不好的地方,总是报错,后面加了重试机制,就是获取数据失败后会自动再获取,重试3次,这样改后,错误是减少了,但是各个操作却变慢了,这如何是好？ 目前暂时还不考虑存本地,然后再上传到服务器这种方案(基于业务原因) 请问下还有其他方案吗？ PS:中间件部署在客户当地时,和增加重试机制的效果类似,因为数据库仍旧在公司总部,客户访问到中间件服务器...
封装read、write、accept、connect函数，实现超时操作。
Chenk的专栏
09-25 4174
学习linux网络编程的时候，看视频学习，封装了一些可以直接拿来用的函数，方便以后查找。 /**  * read_timeout - 读超时检测函数，不含读操作  *@fd: 文件描述符  *@wait_seconds: 等待超时秒数，如果为0表示不检测超时  * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT  */ int read_tim
用户长时间无操作 超时退出系统实现
zishan007的专栏
11-22 7754
在一般系统的拦截器，过滤器基础上， 添加前台一个ajax请求， 定时去问后台的最后一次操作时间， 并前台处理这时间差产生的不同操作， 但是最后一次操作的时间不容易得到， session中虽然存有最后一次操作时间， 但是每次Ajax请求都会更新这个值， 所以要在session中 纪录一个最新操作的值， 在什么时候纪录呢？ 对     就在拦截器，和过滤器中添加最新操作时间，
we.rar_C/S_visual c_局域网通信
09-21
在IT行业中，C/S（Client/Server）架构是一种常见的分布式应用程序设计模式，广泛应用于局域网通信。在这个架构中，客户端（Client）是用户交互的界面，而服务器端（Server）则负责处理业务逻辑和数据存储。Visual ...
C#考试系统单C/S(后台管理系统）
09-05
C/S架构是一种典型的两层架构，由客户端和服务器端组成。在考试系统中，客户端通常为学生端，负责展示试题、接收用户答案并发送至服务器；服务器端则负责处理请求、验证答案、记录成绩等。这种架构能够实现数据的...
Java设置session超时的几种方式总结
08-30
主要介绍了Java设置session超时的几种方式总结的相关资料,需要的朋友可以参考下
详解Golang 中的并发限制与超时控制
09-20
在Golang中，并发控制和超时管理是构建高效、可靠程序的关键部分。本文将深入探讨这两个主题，以便更好地理解和应用它们。 首先，让我们来看并发。Golang通过goroutines和channels实现了轻量级线程的概念，使并发...
详解python中自定义超时异常的几种方法
09-18
主要介绍了详解python中自定义超时异常的几种方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Linux网络编程 超时检测
人生一世 草木一秋
08-19 389
在网络通信过程中，经常会出现不可预知的各种情况。例如，网络线路突发故障、通信一方异常结束等。一旦出现上述情况，很可能长时间都不会收到数据，而且无法判断是没有数据还是数据无法到达。如果使用的是TCP协议，可以检测出来；但如果使用UDP协议的话，需要在程序中进行相关检测。
66-套接字超时（alarm）
进击的小学生
05-02 1201
我们知道，使用 read 或 recvfrom 函数从 socket 上读取数据时，可能会导致阻塞。特别是 UDP 服务器，稍有不甚，数据报就丢失就会直接导致程序假死（阻塞在 recvfrom）。还有 connect 函数，如果去连接一个网络上不存在的主机，需要等待很长时间，可能长达 2 分钟。如果我们能控制它在指定的时间内连接不上，就直接报错，行不行呢？很可惜，上面的问题 linux 并未直接提供
I/O操作上设置超时之alarm闹钟法
satanwxd的专栏
03-01 3698
<br />环境是linux ubuntu系统<br />调用 alarm，它在指定超时期满时产生SIGALRM信号。这个方法涉及信号处理。<br />用法：<br />   alarm(time):TIME就是指定的超时期；如果之前设有超时期，alarm()会返回其时期的剩余值；<br />   signal(SIGALARM, connect_alarm):指定connect_alarm函数是时钟期满时的处理函数；<br />函数退出前要关闭时钟：<br />   Sigfunc   *sigfunc;
C/C++使用信号实现超时功能
bbkgl的博客
10-11 2754
若教眼底无离恨 不信人间有白头 Python可以通过装饰器实现函数的超时，C/C++就得想点别的办法了，可以借助一个操作系统的信号机制。 网上资料很多，这里我直接放代码，一看就懂，其实就调用了两个系统调用。 #include <signal.h> #include <cstdio> #include <unistd.h> void handle(int s...
七、TCP C/S：socket 读写超时设置
weixin_34050427的博客
07-16 1184
2019独角兽企业重金招聘Python工程师标准>>> ...
docker 获取net/http超时怎么办
最新发布
04-07
如果你在使用 Docker 时遇到了获取 net/http 超时的问题，可以尝试以下解决方法： 1. 检查网络连接是否正常，尝试 ping 一下目标地址，看是否能够正常连接。 2. 检查 Docker 网络设置是否正确，可以尝试修改 Docker 网络设置，使用本地镜像加速器等。 3. 检查 Docker 容器内的 DNS 设置是否正确，可以尝试修改容器内的 DNS 设置。 希望以上解决方法能够帮助你解决问题。如果还有其他问题，欢迎随时向我提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值