1. 首页
  2. 文章中心
  3. 网络编程

网络编程：网络超时检测(select poll setsockopt alarm)一、网络超时检测二超时检测的方法：

69 阅读 0 评论
我是靠谱客的博主 称心树叶，最近开发中收集的这篇文章主要介绍网络编程：网络超时检测(select poll setsockopt alarm)一、网络超时检测二超时检测的方法：，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一、网络超时检测

1.1 概念

阻塞：

以读阻塞为例，如果缓冲区中有内容，则程序正常执行，

如果缓冲区没有内容，程序会一直阻塞，直到有内容，读取内容继续向下运行。

非阻塞:

以读阻塞为例，如果缓冲区中有内容，则程序正常执行，

如果缓冲区没有内容，程序会立即返回，然后继续向下运行。

超时检测：

介于阻塞和非阻塞之间，需要设置一定的时间，如果时间到达之前，缓冲区中没有数据

程序会阻塞，如果时间到了，缓冲区中还没有数据，则程序立即返回，继续向下执行。

二超时检测的方法：

2.3以下所用程序的客户端：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#define N 128

#define ERRLOG(msg) do{
    printf("%s,%s,[%d]n", __FILE__, __func__, __LINE__);
    perror(msg);
    exit(-1);
}while(0)

int main(int argc, char const *argv[])
{
    if (argc != 3){
        ERRLOG("输入参数错误n");
    }

    int socketfd;
    if (-1 == (socketfd = socket(AF_INET, SOCK_STREAM, 0))){
        ERRLOG("socket fd error");
    }

    struct sockaddr_in clientaddr;
    clientaddr.sin_family = AF_INET;
    clientaddr.sin_addr.s_addr = inet_addr(argv[1]);
    clientaddr.sin_port = htons(atoi(argv[2]));
    socklen_t clientaddr_len = sizeof(clientaddr);

    if (-1 == connect(socketfd,(struct sockaddr*)&clientaddr, clientaddr_len)){
        ERRLOG("connect error");
    } 

    printf("连接成功...n");

    char buff[N];
    while (1){
        memset(buff, 0, sizeof(buff));

        printf("请输入>>");
        fgets(buff, N, stdin);
        buff[strlen(buff) -1] = '';

        if (-1 == send(socketfd, buff, strlen(buff), 0)){
            ERRLOG("send error");
        }

        if (strncmp("quit", buff, 5) == 0){
            break;
        }
        memset(buff, 0, sizeof(buff));
        if (-1 == recv(socketfd, buff, sizeof(buff), 0)){
            ERRLOG("recv error");
        }

        printf("%sn", buff);
    }

    close(socketfd);
    return 0;
}

2.2select函数自带超时检测

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/select.h>
#define N 128

#define ERRLOG(msg) do{
    printf("%s,%s,[%d]n", __FILE__, __func__, __LINE__);
    perror(msg);
    exit(-1);
}while(0)

int main(int argc, char const *argv[])
{
    if (argc != 3){
        printf("输入格式错误n");
        exit(-1);
    }

    int socketfd;

    if (-1 == (socketfd = socket(AF_INET, SOCK_STREAM, 0))){
        ERRLOG("socketfd erro");
    }

    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t serveraddr_len = sizeof(serveraddr);

    if (-1 == bind(socketfd, (struct sockaddr*)&serveraddr, serveraddr_len)){
        ERRLOG("bind error");
    }
    
    if (-1 == listen(socketfd, 5)){
        ERRLOG("listen error");
    }

    int nbytes;
    int ret;
    int i;
    int maxfd = 0;
    int acceptfd;
    char buff[128] = {0};

    fd_set readfs;
    fd_set readfs_temp;
    FD_ZERO(&readfs);
    FD_ZERO(&readfs_temp);

    FD_SET(socketfd, &readfs);
    maxfd = maxfd > socketfd ? maxfd: socketfd;
    
    struct timeval tm;
    while (1){
        readfs_temp = readfs;
        tm.tv_sec = 5;
        tm.tv_usec = 0;
        if (-1 == (ret = select(maxfd + 1, &readfs_temp, NULL, NULL, &tm))){
            ERRLOG("select error");
        } else if (ret == 0){
            printf("timeout.....n");
        } else {
            for (i = 3; i < maxfd + 1 && ret != 0; i++){
                if (FD_ISSET(i, &readfs_temp)){
                    if (i == socketfd){
                        if (-1 == (acceptfd = accept(i, NULL, NULL))){
                            ERRLOG("acceptfd error");
                        }
                            printf("111111111n");
                        FD_SET(acceptfd, &readfs);

                        maxfd = maxfd > acceptfd ? maxfd : acceptfd;
                    } else {
                        memset(buff, 0, sizeof(buff));

                        if (-1 == (nbytes = recv(i, buff, sizeof(buff), 0))){
                            ERRLOG("recv error");
                        } else if(nbytes == 0){
                            printf("断开链接...n");
                            FD_CLR(i, &readfs);
                            close(i);
                            continue;
                        }

                        if (!strncmp("quit", buff, 5)){
                            printf("退出链接...n");
                            FD_CLR(i, &readfs);
                            close(i);
                            continue;
                        }

                        printf("%sn", buff);

                        strcat(buff, "hhhh");

                        if (-1 == send(i, buff, sizeof(buff), 0)){
                            ERRLOG("send error");
                        }
                    }
                    ret--;
                }
            }
        }   
    }
    close(socketfd);
    return 0;
}

2.2poll函数也自带超时器

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

#define ERRLOG(msg) do{
        printf("%s %s(%d):", __FILE__, __func__, __LINE__);
        perror(msg);
        exit(-1);
    }while(0)

#define N 128


int main(int argc, char const *argv[])
{
    if (argc != 3){
        printf("输入过程n");
        exit(-1);
    }

    int socketfd;
    if (-1 == (socketfd = socket(AF_INET, SOCK_STREAM, 0))){
        ERRLOG("socket error");
    }

    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    serveraddr.sin_port = htons(atoi(argv[2]));
    socklen_t serveraddr_len = sizeof(serveraddr);

    if (-1 == bind(socketfd, (struct sockaddr*)&serveraddr, serveraddr_len)){
        ERRLOG("bind error");
    }

    if (-1 == listen(socketfd, 5)){
        ERRLOG("listen error");
    }

    int maxfd = 0;
    int ret = 0;
    int nbytes = 0;
    int i;
    int j;
    int acceptfd;
    char buff[128];

    struct pollfd my_fds[1024];
    for (i = 0; i < 1024; i++){
        my_fds[i].fd = -1;
    }

    my_fds[0].fd = socketfd;
    my_fds[0].events |= POLLIN;
    maxfd = maxfd > socketfd ? maxfd : socketfd;

    while (1){
        if (-1 == (ret = poll(my_fds, maxfd, 5000))){

        } else if (ret == 0){
            printf("time out...n");
        } else {
            for (i = 0; i <= maxfd && ret != 0; i++){
                if (my_fds[i].revents & POLLIN != 0){
                    if (my_fds[i].fd == socketfd){ 
                        if (-1 == (acceptfd = accept(socketfd, NULL, NULL))){
                            ERRLOG("accepfd error");
                        }

                        printf("客户端[%d]连接了n", acceptfd);

                        maxfd = maxfd > acceptfd ? maxfd : acceptfd;

                        for (j = 0; j < 1024 ; j++){
                            if (my_fds[j].fd == -1){
                                my_fds[j].fd = acceptfd;
                                my_fds[j].events = POLLIN;

                                break;                                
                            }
                        }

                        if (j == 1024){
                            printf("满了n");
                            close(acceptfd);
                        }
                    }else {
                        memset(buff, 0, sizeof(buff));

                        if (-1 == (nbytes = recv(my_fds[i].fd, buff, 128, 0))){
                            ERRLOG("recv error");
                        }else if (nbytes == 0){
                            printf("断开连接...n");
                            close(my_fds[i].fd);
                            my_fds[i].fd = -1;
                            continue;
                        }

                        if (!strncmp("quit", buff, 5)){
                            printf("退出连接..n");
                            printf("断开连接...n");
                            close(my_fds[i].fd);
                            my_fds[i].fd = -1;
                            continue;
                        }

                        printf("%sn", buff);

                        strcat(buff, "jhhh");

                        if (-1 == send(my_fds[i].fd, buff, sizeof(buff), 0)){
                            ERRLOG("send errro");
                        }
                    }
                }
            }
        }
    }


    close(socketfd);
    return 0;
}

2.3使用 setsockopt 函数实现超时检测

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

#define ERRLOG(msg) do{
        printf("%s %s(%d):", __FILE__, __func__, __LINE__);
        perror(msg);
        exit(-1);
    }while(0)

#define N 128

typedef struct _MSG{
    int acceptfd;
    struct sockaddr_in clientaddr;
}msg_t;

void *deal_read_write(void *arg){
    msg_t msg = *(msg_t *)arg;
    char buff[N] = {0};
    int nbytes = 0;
    printf("客户端 [%s:%d] 连接了n", inet_ntoa(msg.clientaddr.sin_addr), ntohs(msg.clientaddr.sin_port));
    
    //收发数据
    while(1){
        memset(buff, 0, N);
        //接受数据
        //由已经设置过超时时间的sockfd产生的accpetfd会继承超时属性
        //如果想设置的超时时间是一样的，直接使用即可
        //如果不想设置一样，也可以对每个acceptfd单独调用 setsockopt 进行设置
        if(-1 == (nbytes = recv(msg.acceptfd, buff, 128, 0))){
            if(errno == EAGAIN){
                printf("recv timeout..n");
                close(msg.acceptfd);
                break;
            }
            perror("recv error");
            break;
        }else if(0 == nbytes){
            printf("[%s:%d]:断开了连接...n", inet_ntoa(msg.clientaddr.sin_addr), ntohs(msg.clientaddr.sin_port));
            break;
        }
        if(!strncmp(buff, "quit", 5)){
            printf("[%s:%d]:退出了...n", inet_ntoa(msg.clientaddr.sin_addr), ntohs(msg.clientaddr.sin_port));
            break;
        }
        //打印数据
        printf("[%s:%d]:[%s]n", inet_ntoa(msg.clientaddr.sin_addr), ntohs(msg.clientaddr.sin_port), buff);
        //组装应答
        strcat(buff, "--hqyj");
        //发送应答
        if(-1 == send(msg.acceptfd, buff, N, 0)){
            ERRLOG("send error");
        }
    }
    close(msg.acceptfd);
    pthread_exit(NULL);
}

int main(int argc, const char *argv[]){
    if(3 != argc){
        printf("Usage: %s <IP> <port>n", argv[0]);
        return -1;
    }

    //创建流式套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(-1 == sockfd){
        ERRLOG("socket error");
    }

    //填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    //网络字节序的端口号 8888  9999  6789 等 都可以
    serveraddr.sin_port = htons(atoi(argv[2]));
    //网络字节序的IP地址，IP地址不能乱填
    //自己的主机ifconfig 查到的ip地址是多少就填多少
    //如果本机测试使用 也可以填写 127.0.0.1
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    
    socklen_t serveraddr_len = sizeof(serveraddr);

    //设置允许端口复用
    int on = 1;
    if(-1 == setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))){
        perror("setsockopt error");
    }

    //将套接字和网络信息结构体绑定
    if(-1 == bind(sockfd, (struct sockaddr *)&serveraddr, serveraddr_len)){
        ERRLOG("bind error");
    }

    //将套接字设置成被动监听状态
    if(-1 == listen(sockfd, 5)){
        ERRLOG("listen error");
    }

    //设置sockfd接收超时时间为 5s
    struct timeval tm;
    tm.tv_sec = 5;
    tm.tv_usec = 0;
    if(-1 == setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tm, sizeof(tm))){
        ERRLOG("setsockopt error");
    }

    //定义一个保存客户端信息的结构体
    struct sockaddr_in clientaddr;
    memset(&clientaddr, 0, sizeof(clientaddr));
    socklen_t clientaddr_len = sizeof(clientaddr);

    msg_t msg;
    pthread_t tid = 0;

    //阻塞等待客户端连接
    int acceptfd = 0;
    while(1){
        if(-1 == (acceptfd = accept(sockfd, (struct sockaddr *)&clientaddr, &clientaddr_len))){
            if(errno == EAGAIN){
                printf("5秒内没有客户端连接到服务器..n");
                continue;
            }
            ERRLOG("acceptfd error");
        }
        memset(&msg, 0, sizeof(msg));
        msg.clientaddr = clientaddr;
        msg.acceptfd = acceptfd;
        //有客户端连接就创建线程专门处理读写
        if(0 != pthread_create(&tid, NULL, deal_read_write, (void *)&msg)){
            ERRLOG("pthread_create error");
        }

        //设置线程分离属性 由操作系统回收线程的资源
        pthread_detach(tid);
    }

    close(sockfd);

    return 0;
}

2.4使用 alarm 闹钟实现超时检测

2.4.1 概念

alarm是一个函数，可以通过他设置一个时间，当时间到达的时候，会给进程发一个

SIGALRM 信号。

使用alarm函数设置完超时时间后，进程会继续执行，直到设置的时间到了，

进程收到 SIGALRM 信号

进程对该信号默认的处理方式是 终止进程，我们的是服务器程序，不能使用默认的方式

所以需要对 该信号进行一个捕捉的操作。

如果使用 捕捉的操作，当信号产生时，回去执行信号处理函数，执行完信号处理函数

进程会继续向下执行，这种属性，叫做信号的自重启属性。

我们想要使用该信号实现超时检测，也就是说，执行完信号处理函数，不应该直接向下运行

而是应该给我们返回一个错误，也就是说，需要关闭信号的自重启属性。

2.4.2关闭自重启属性的方式，使用 sigaction 函数

struct sigaction action;
//获取旧的行为
sigaction(SIGALRM, NULL, &action);
//取消自重启属性
action.sa_flags &= (~SA_RESTART);
//指定信号处理函数
action.sa_handler = my_function;
//再将行为重新设置回去
sigaction(SIGALRM, &action, NULL);

2.4.3代码实现

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

#define ERRLOG(msg) do{
	printf("%s %s(%d):", __FILE__, __func__, __LINE__);
	perror(msg);
	exit(-1);
}while(0)

#define N 128

void my_function(int x){
	//什么都不用作  我们只是通过这种方法捕获信号
	printf("hellen");
}

int main(int argc, const char *argv[]){
	if(3 != argc){
		printf("Usage: %s <IP> <port>n", argv[0]);
		return -1;
	}

	//创建流式套接字
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(-1 == sockfd){
		ERRLOG("socket error");
	}

	//填充服务器网络信息结构体
	struct sockaddr_in serveraddr;
	memset(&serveraddr, 0, sizeof(serveraddr));
	serveraddr.sin_family = AF_INET;
	//网络字节序的端口号 8888  9999  6789 等 都可以
	serveraddr.sin_port = htons(atoi(argv[2]));
	//网络字节序的IP地址，IP地址不能乱填
	//自己的主机ifconfig 查到的ip地址是多少就填多少
	//如果本机测试使用 也可以填写 127.0.0.1
	serveraddr.sin_addr.s_addr = inet_addr(argv[1]);

	socklen_t serveraddr_len = sizeof(serveraddr);

	//设置端口复用
	int on = 1;
	if(-1 == setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))){
		perror("setsockopt error");
	}

	//将套接字和网络信息结构体绑定
	if(-1 == bind(sockfd, (struct sockaddr *)&serveraddr, serveraddr_len)){
		ERRLOG("bind error");
	}

	//将套接字设置成被动监听状态
	if(-1 == listen(sockfd, 5)){
		ERRLOG("listen error");
	}

	//定义一个保存客户端信息的结构体
	struct sockaddr_in clientaddr;
	memset(&clientaddr, 0, sizeof(clientaddr));
	socklen_t clientaddr_len = sizeof(clientaddr);

	char buff[N] = {0};
	int nbytes = 0;

	//关闭SIGALRM信号的自重启属性
	struct sigaction action;
	//获取旧的行为
	sigaction(SIGALRM, NULL, &action);
	//取消自重启属性
	action.sa_flags &= (~SA_RESTART);
	//指定信号处理函数
	action.sa_handler = my_function;
	//再将行为重新设置回去
	sigaction(SIGALRM, &action, NULL);

	//阻塞等待客户端连接
	int acceptfd = 0;
	while(1){
		alarm(5);
		if(-1 == (acceptfd = accept(sockfd, (struct sockaddr *)&clientaddr, &clientaddr_len))){
			if(errno == EINTR){
				printf("accept timeout..n");
				continue;
			}
			ERRLOG("acceptfd error");
		}
		printf("客户端 [%s:%d] 连接了n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));

		//收发数据
		while(1){
			memset(buff, 0, N);
			//接受数据
			alarm(5);
			if(-1 == (nbytes = recv(acceptfd, buff, 128, 0))){
				if(errno == EINTR){
					printf("recv timeout..n");
					break;
				}
				ERRLOG("recv error");
			}else if(0 == nbytes){
				printf("[%s:%d]:断开了连接...n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
				break;
			}
			if(!strncmp(buff, "quit", 5)){
				printf("[%s:%d]:退出了...n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
				break;
			}
			//打印数据
			printf("[%s:%d]:[%s]n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port), buff);
			//组装应答
			strcat(buff, "--hqyj");
			//发送应答
			if(-1 == send(acceptfd, buff, N, 0)){
				ERRLOG("send error");
			}
		}
		//关闭套接字
		close(acceptfd);
	}

	//这句代码一般不会执行到
	//服务器程序一般不会主动退出
	close(sockfd);

	return 0;
}

最后

以上就是称心树叶为你收集整理的网络编程：网络超时检测(select poll setsockopt alarm)一、网络超时检测二超时检测的方法：的全部内容，希望文章能够帮你解决网络编程：网络超时检测(select poll setsockopt alarm)一、网络超时检测二超时检测的方法：所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(46)

相关文章

简单的几种网络超时检测
简单的几种网络超时检测
Debezium系列之：增加心跳检测一、需求背景二、心跳检测含义三、增加心跳检测参数四、查看心跳检测topic
Debezium系列之：增加心跳检测一、需求背景二、心跳检测含义三、增加心跳检测参数四、查看心跳检测topic
网络超时检测的方法
网络超时检测的方法
C#【多线程篇】模拟网络通信定时心跳检测连接状态（AutoResetEvent）
C#【多线程篇】模拟网络通信定时心跳检测连接状态（AutoResetEvent）
网络编程：网络超时检测(select poll setsockopt alarm)一、网络超时检测二超时检测的方法：
网络编程：网络超时检测(select poll setsockopt alarm)一、网络超时检测二超时检测的方法：
Qt使用TCP实现的简单服务端和客户端(带心跳检测)
Qt使用TCP实现的简单服务端和客户端(带心跳检测)
tcp心跳机制一、心跳包二、TCP协议的KeepAlive机制
tcp心跳机制一、心跳包二、TCP协议的KeepAlive机制
TCP心跳检测包                                      TCP心跳检测包
TCP心跳检测包                                      TCP心跳检测包

评论列表共有 0 条评论

立即
投稿
返回
顶部