关于epoll, select, poll的实现demo

最新推荐文章于 2022-02-19 11:45:22 发布
最新推荐文章于 2022-02-19 11:45:22 发布
阅读量607 收藏 3
点赞数
分类专栏： c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37190845/article/details/103751514
版权

client.c

//client.c
#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<string.h>
static void usage(const char* proc) {
	printf("Usage:%s [server-ip] [server-port]",proc);
}
int main(int argc,char *argv[]) {
	if(argc != 3) {
		usage(argv[0]);
	}
	int sock = socket(AF_INET,SOCK_STREAM,0);
	if(sock < 0) {
		perror("socket");
		return 1;
	}
	struct sockaddr_in server;
	server.sin_family = AF_INET;
	server.sin_port = htons(atoi(argv[2]));
	server.sin_addr.s_addr = inet_addr(argv[1]);
	if(connect(sock,(struct sockaddr *)&server,sizeof(server)) < 0) {
		perror("connect");
		return 2;
	}
	while(1) {
		printf("please Entry#");
		fflush(stdout);
		char buf[1024];
		ssize_t s = read(0,buf,sizeof(buf)-1);
		if(s > 0) {//read success
			buf[s] = 0;
		}
		printf("%d\n", sock);
		write(sock,buf,strlen(buf));
		ssize_t _s = read(sock,buf,sizeof(buf)-1);
		if(_s > 0) {
			buf[_s - 1] = 0;
			printf("server echo# %s\n",buf);
		}
	}
	close(sock);
	return 0;
}

select.c

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

void Usge(const char* proc) {
	printf("%s[local_ip] [local_port]\n", proc);
}

int array[500];

static int start_up(const char* _ip, int _port) {
	int sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock < 0) {
		perror("socket error");
		exit(1);
	}

	struct sockaddr_in local;
	local.sin_family = AF_INET;
	local.sin_port = htons(_port);
	local.sin_addr.s_addr = inet_addr(_ip);

	bind(sock, (struct sockaddr*)&local, sizeof(local));
	listen(sock ,10);
	return sock;
}


int main(int argc, char const *argv[])
{
	if (argc < 3) {
		perror("argc error");
		return 0;
	}

	int listensocket = start_up(argv[1], atoi(argv[2]));
	int maxfd = 0;
	fd_set rfds; // 可读的集合
	fd_set wfds; // 可写的集合
	array[0] = listensocket; // 保存监视的文件描述符

	int i  = 1;
	int array_size = sizeof(array)/sizeof(array[0]);
	for (; i < array_size; i++) {
		array[i] =  0;
	}

	while (1) {
		FD_ZERO(&rfds);
		FD_ZERO(&wfds);

		printf("while\n");
		for (i = 0 ; i < array_size; i++) {
			if (array[i] > 0) {
				FD_SET(array[i], &rfds);
				FD_SET(array[i], &wfds);
				if (array[i] > maxfd) {
					maxfd = array[i];
				}
			}
		}

		switch (select(maxfd+1, &rfds, &wfds, NULL, NULL)) { // 此时会一直阻塞
			case 0:{
				printf("timeout\n");
				break;
			}
			case -1:{
				printf("select\n");
				break;
			}

			default: {
				int j = 0;
				for (; j < array_size; j++) {
					if  (j == 0 && FD_ISSET(array[j], &rfds)) {
						// listen sock haapend read events
						struct sockaddr_in client;
						socklen_t len = sizeof(client);
						int new_sock = accept(listensocket, (struct sockaddr*)&client, &len);
						printf("get a new client%s\n", inet_ntoa(client.sin_addr));
						fflush(stdout);
						int k = 1;
						for (; k < array_size ; k++) {
							if (array[k] == 0) {
								array[k] = new_sock;
								printf("%d\n", new_sock);
								if (new_sock > maxfd) 
								maxfd = new_sock;
								break;
							}
						}

						if (k == array_size) {
							close(new_sock);
						}
					} else if (j != 0 && FD_ISSET(array[j], &rfds)) {
						// new sock happend read events
						char buf[1024];
						ssize_t s = read(array[j], buf, sizeof(buf)-1);
						if (s > 0) {
							buf[s] = 0;
							printf("clients say##%s\n", buf);
							if (FD_ISSET(array[j], &wfds)) {
								char *msg = "nihaoma";
								write(array[j], msg, strlen(msg));
							}
						} else if (s == 0){
							printf("client quit!\n");
							close(array[j]);
							array[j] = -1;
						} else {
							perror("reasdfsdfsd");
							close(array[j]);
							array[j] = -1;
						}
					}
				}
			}
		}
	}
	return 0;
}

poll.c

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

void Usge(const char* proc) {
	printf("%s[local_ip] [local_port]\n", proc);
}

int array[500];

static int start_up(const char* _ip, int _port) {
	int sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock < 0) {
		perror("socket error");
		exit(1);
	}

	struct sockaddr_in local;
	local.sin_family = AF_INET;
	local.sin_port = htons(_port);
	local.sin_addr.s_addr = inet_addr(_ip);

	bind(sock, (struct sockaddr*)&local, sizeof(local));
	listen(sock ,10);
	return sock;
}

int main(int argc, char *argv[])
{
	int sock = start_up(argv[1], atoi(argv[2]));

	struct pollfd peerfd[1024];
	peerfd[0].fd = sock;
	peerfd[0].events = POLLIN;

	int nfds = 1;
	int ret;
	int maxsize = sizeof(peerfd)/sizeof(peerfd[0]);
	int i = 1;
	int timeout = -1;
	for (; i < maxsize; i++) {
		peerfd[i].fd = -1;
	}

	while (1) {
		switch (ret = poll(peerfd, nfds, timeout)) {
			case 0:
				printf("timeout....\n");
				break;
			case -1:
				printf("poll error\n");
				break;
			default:
				{
					if (peerfd[0].revents & POLLIN) {
						struct sockaddr_in client;
						socklen_t len = sizeof(client);
						int new_sock = accept(sock, (struct sockaddr*)&client, &len);
						printf("accpet finish: %d\n", new_sock);
						printf("get a new client#\n");
						int j = 1;
						for (; j < maxsize; j++) {
							if (peerfd[j].fd < 0) {
								peerfd[j].fd = new_sock;
								peerfd[j].events = POLLIN;
								if (j + 1 > nfds) {
									nfds = j+1;
								}
								break;
							}
						}
					}

					//
					for (int i = 1; i < nfds; i++) 
					{
						if (peerfd[i].revents & POLLIN) {
							printf("read readly:\n");
							char buf[1024];
							ssize_t s = read(peerfd[i].fd, buf, sizeof(buf) - 1);
							if (s > 0) {
								buf[s] = 0;
								printf("client say# %s\n", buf);
								fflush(stdout);
								peerfd[i].events = POLLOUT;
							} else {
								close(peerfd[i].fd);
								peerfd[i].fd = -1;
							}
						}

						if (peerfd[i].revents & POLLOUT) {
							char *msg = "duanzhihong";
							write(peerfd[i].fd, msg, strlen(msg));
							peerfd[i].events = POLLIN;
						}
					}
				}
			break;
		}
	}

	return 0;
}

epoll.c

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

static Usage(const char proc)
{
	printf("%s[local_ip][local_port]\n", proc);
}

int start_up(const char*_ip, int _port)
{
	int sock = socket(AF_INET, SOCK_STREAM, 0);
	struct sockaddr_in local;
	local.sin_family = AF_INET;
	local.sin_port = htons(_port);
	local.sin_addr.s_addr = inet_addr(_ip);
	bind(sock, (struct sockaddr*)&local, sizeof(local));
	listen(sock, 10);
	return sock;
}

int main(int argc, char *argv[])
{
	if (argc < 3) {
		Usage(argv[0]);
		exit(1);
	}

	int sock = start_up(argv[1], atoi(argv[2]));
	int epollfd = epoll_create(256);
	struct epoll_event ev;
	ev.events = EPOLLIN:
	ev.data.fd = sock;
	epoll_ctl(epollfd, EPOLL_CTL_ADD, sock, &ev);

	int evnums = 0;
	struct epoll_event evs[64];
	int timeout = -1;

	while (1) {
		switch (evnums = epoll_wait(epollfd, evs, 64, timeout)) {
			case 0;
			printf("timeout.....\n");
			break;
			case -1:
			printf("epoll_wait error\n");
			break;
			default:
			{
				int i = 0;
				for (; i < evnums; ++i) {
					struct sockaddr_in client;
					socklen_t len = sizeof(client);
					if (evs[i].data.fd == sock && evs[i].events & EPOLLIN) {
						int new_sock = accept(sock, (struct sockaddr*)&client, &len);
						printf("get a new client#:\n");
						inet_ntoa(client.sin_addr);
						ev.data.fd = new_sock;
						ev.data = EPOLLIN;
						epoll_ctl(epollfd, EPOLL_CTL_ADD, new_sock, &ev);
					} else if (evs[i].data.fd != sock && evs[i].events & EPOLLIN) {
						char buf[1024];
						ssize_t s = read(evs[i].data.fd, buf, sizeof(buf) - 1);
						if (s > 0) {
							buf[s] = 0;
							printf('client say##\n');
							ev.data.fd = evs[i].data.fd;
							ev.events = EPOLLOUT;
							epoll_ctl(epollfd, EPOLL_CTL_MOD, eves[i].dta.fd);
						} else {
							close(evs[i].data.fd);
							epoll_ctl(epoll, EPOLL_CTL_DEL, evs[i].data.fd, NULL);
						}
					} else if (evs[i].data.fd != sock && evs[i].events & EPOLLOUT) {
							char *msg = "that\'s ok";
							write(evs[i].data.fd, msg, strlen(msg));
					}
				}
			}
			break;
		}

	}

	return 0;
}

时间复杂度:O(n)

fd_set(监听的端口个数)：32位机默认是1024个，64位机默认是2048。

缺点：

    （1）单进程可以打开fd有限制；

    （2）对socket进行扫描时是线性扫描，即采用轮询的方法，效率较低；

    （2）用户空间和内核空间的复制非常消耗资源；

时间复杂度:O(1)

epoll的工作方式

epoll的两种工作方式：1.水平触发（LT）2.边缘触发（ET）
LT模式：若就绪的事件一次没有处理完要做的事件，就会一直去处理。即就会将没有处理完的事件继续放回到就绪队列之中（即那个内核中的链表），一直进行处理。
ET模式：就绪的事件只能处理一次，若没有处理完会在下次的其它事件就绪时再进行处理。而若以后再也没有就绪的事件，那么剩余的那部分数据也会随之而丢失。
由此可见：ET模式的效率比LT模式的效率要高很多。只是如果使用ET模式，就要保证每次进行数据处理时，要将其处理完，不能造成数据丢失，这样对编写代码的人要求就比较高。
注意：ET模式只支持非阻塞的读写：为了保证数据的完整性。

在这里插入图片描述

原文链接：https://blog.csdn.net/nanxiaotao/article/details/90612404

有一片海
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
彻底搞懂 select/poll/epoll，就这篇了
m0_71777195的博客
06-14 1352
之前已经把网络 I/O 相关要点都盘了，还剩 select/poll/epoll 这几个区别没说，这篇就来搞搞它们，并且是从完全理解原理的角度来区分它们。本来是要上源码的，但是感觉没啥必要，身为应用开发者我觉得理解原理就行了，源码反正看了就忘了，理解才是最重要！所以我就尽量避免代码且用大白话来盘一盘这三个玩意。话不多说，发车。首先，我们知道 select/poll/epoll 是用来实现多路复用的，即一个线程利用它们即可 hold 诸多个 socket。按照这个思路，线程不可能被任何一个被管理的 Socke
IO多路复用的select, poll, epoll之间的区别和联系总结
技术笔记
05-20 5948
IO多路复用 select, poll和epoll都是IO多路复用的模型，所以在深入了解这三个系统调用之前，需要先简单介绍一下IO多路复用。 IO多路复用是一种复用技术，复用(multiplexing)技术很普遍，例如通信中有多路时分复用（OFDM）、频分复用、码分复用。再例如我们一个办公室的人可以共用办公室的一台打印机，大家在不同的时段使用即可实现复用，这就是时分复用。 “IO多路复用”是指复用了同一个处理线程（在Java中被抽象为选择器selector），由操作系统进行托管，当与选择器绑定的socket
linux poll函数
热门推荐
qq69696698的专栏
04-18 1万+
# include int poll ( struct pollfd * fds, unsigned int nfds, int timeout); 和select()不一样，poll()没有使用低效的三个基于位的文件描述符set，而是采用了一个单独的结构体pollfd数组，由fds指针指向这个组。pollfd结构体定义如下：   # include struct pollfd {
网络编程：PollServer的demo
代码笔记本
02-19 580
tcpServer.hpp #pragma once #include<iostream> #include<string> #include<cstdio> #include<cstring> #include<string.h> #include<typeinfo> #include<exception> #include<stdexcept> #include<arpa/inet.h> #in
转 epoll的一个demo（epoll+线程池）
zhaoxiaozheng1987的博客
08-30 453
#include #include #include #include #include #include   #include #include #include #include   #define THREAD_MAX 20 #define LISTEN_MAX 20 #define SERVER_IP "127.0.0.1"   ty
IO复用--epoll(demo)
一只青木呀
07-17 808
poll的调用和select完全一致 优点：连接数（也就是文件描述符）没有限制（链表存储） 缺点：大量拷贝，水平触发（当报告了fd没有被处理，会重复报告，很耗性能） epoll epoll是linux内核为处理大批量文件描述符而作了改进的poll，是linux下IO复用select/poll的增强版本。 并发性高，可同时监听C10K以上级别的客户事件 select ----> fd—>fd_set --轮训 poll ---- fd—>pollfd epoll ---->
linux的poll函数,linux poll函数(示例代码)
weixin_36332642的博客
05-09 617
poll函数与select函数差不多函数原型：#include int poll(struct pollfd fd[], nfds_t nfds, int timeout);struct pollfd的结构如下：structpollfd{int fd； //文件描述符short event；//请求的事件short revent；//返回的事件}每个pollfd结构体指定了一个被监视的文件描述符。...
select poll epoll
07-30
`select`、`poll`和`epoll`是Linux系统中用于处理多路复用I/O的主要机制，它们允许程序同时监控多个文件描述符（FDs），等待数据就绪后再进行处理。下面将详细介绍这三个方法，并对比它们的特点和使用场景。 ### 1....
请说明Unix网络编程中select,poll和epoll的区别，并用C语言实现一个使用select，poll和epoll进行通信的demo
05-27
下面是一个使用select、poll和epoll进行通信的demo，该程序可以监听本地端口，并接受客户端的连接请求，然后将客户端发送的数据原样返回。 ```c #include #include #include #include #include #include #...
epoll demo(LT和ET)
04-10
**epoll**是Linux内核提供的一种高效I/O事件通知机制，它替代了传统的`poll`和`select`，在高并发I/O处理场景中表现出色。本篇将深入讲解`epoll`的工作原理，以及如何实现`Level Triggered (LT)`模式和`Edge ...
一个poll的使用例子
01-26
一个关于poll的使用的例子，里面有些注释，
功能完整的epoll tcp服务器和C#客户端，包括接收超时处理、粘包拆包，对收到的数据进行CRC验证然后处理
05-15
功能完整的epoll tcp服务器和C#客户端，包括接收超时处理、粘包拆包，对收到的数据进行CRC验证然后处理
Linux C++ epoll使用范例
03-18
里面包含了一些epoll的使用范例代码，有客户端和服务端，还有一个测试程序
epoll demo 代码
04-08
在传统的文件描述符轮询或select/poll模型中，随着监听的文件描述符数量增加，性能会显著下降。而epoll通过引入“事件多路复用”解决了这个问题，它允许程序注册多个文件描述符，并在这些描述符上有事件发生时，仅...
socket编程select函数处理多个I/O并发
qq_22753933的博客
09-23 564
//本程序仅对客户端进行处理多个并发的I/O //服务器端 #include &lt;unistd.h&gt; #include &lt;sys/types.h&gt; #include &lt;sys/socket.h&gt; #include &lt;netinet/in.h&gt; #include &lt;arpa/inet.h&gt; #include &lt;signal.h&gt;/...
【Poll】Linux Poll源码
sinat_33822516的博客
02-08 394
上一篇博客大致分析了select的源码，其实poll和select的实现基本上是相同，只是poll改进了一些select的缺点 1. select可以监听的描述符是有限的，默认是1024个，因为select使用fd_set这个数据结构来保存要监听的描述符，其实fd_set就是一个unsigned long数组，这个数组默认是16，也就是16*8*8=1024。具体可以参考我上一篇博客Linux Select源码。 2. 每次select返回后，response fd_set都被重置了，所以用户态的程.
Linux select和poll系统调用
Tracy Mcgrady的专栏
08-11 1470
很多时候，我们调用read函数从文件描述符中读取数据时，如果此时恰好没有数据可读，read系统调用势必会阻塞住。同样，当调用write函数时，而没有空间供我们写入，write系统调用也会被阻塞住，直到有空间被写入时。那么在这种情况下我们为了不阻塞我们的程序，就需要检查文件描述符是否可读或可写。 1. select系统调用 首先我们来看一段代码：#include #include in
poll()函数学习笔记(适合小白理解)
zed_killer的博客
09-19 8479
在工作中遇到了poll()函数，决定来了解一下，参考《UNIX环境高级编程》。 我的理解是：poll()函数有一个监听池，我们把要监听的文件描述符以及我们对该描述符感兴趣的条件(读，写等等)放进池子里，然后就等poll()帮我们监听，等poll()正常返回时，就是有描述符发生了变化，我们通过遍历找到这个变化的文件描述符，再去进行相应的操作(读，写等等)即可。 函数原型： #include ...
select和epoll的总结
codePlayer77的博客
10-28 240
select和epoll 是解决I/O多路复用的机制 FD_ZERO(fd,fdset); FD_SET(fd,fdset); FD_ISSET(fd,fdset); select(fdmaxplus1,readfds,writefds,errorfds,timeval)1、只要三个fd集至少有一个就绪的文件描述符，则返回，否则阻塞到timeout 2、其本质是利用阻塞的方式处理多个非阻塞的
epoll select poll区别
最新发布
07-27
epoll、select和poll是用于实现I/O多路复用的机制，它们之间有以下区别： 1. 存储方式：select和poll采用轮询的方式来检查文件描述符是否处于就绪态，而epoll采用回调机制。这意味着随着文件描述符数量的增加，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值