网络编程 并发执行 线程 进程 IO复用 select poll

最新推荐文章于 2024-09-20 11:08:14 发布
最新推荐文章于 2024-09-20 11:08:14 发布
阅读量405 收藏
点赞数
分类专栏： linux 程序设计 文章标签： 网络编程 并发 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jingli14/article/details/47786939
版权

并发服务器实现  线程 进程 函数 select poll  代码实现   具体理论细节还需要补充

1. //并发服务器 创建线程负责数据交互

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include<string.h>
extern int errno;

void *routine(void *arg)
{
   int newfd=(int)arg;
   char buf[100];
   while(1)
   {
       int cnt1=read(newfd,buf,100);
       printf("threadid=%u,fd=%d\n",pthread_self(),newfd);
       write(1,buf,cnt1);
       if(strncmp(buf,"quit",4)==0)
              break;
   }
   printf("threadid %u exit\n",pthread_self());
   close(newfd);
   pthread_exit();
   return NULL;
}

int main()
{
   //socket
   int fd=socket(AF_INET,SOCK_STREAM,0);
   //绑定地址  协议 端口 ip
   struct sockaddr_in servaddr;
   servaddr.sin_family = AF_INET;
   servaddr.sin_port = htons(1234);
   servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
   printf("server:  ip:%s   port:%d\n",inet_ntoa(servaddr.sin_addr),ntohs(servaddr.sin_port));
   int ret=bind(fd,(struct sockaddr *)&servaddr,sizeof(servaddr));
   if(ret<0)
   {
      fprintf(stderr,"error:%s\n",strerror(errno));
      close(fd);
      return -1;
   }
   //服务器监听
   listen(fd,5);
 
   while(1)
   {
	   pthread_t tid;
	   int newfd;
	   struct sockaddr_in peer;
	   socklen_t size=sizeof(peer);
	   printf("waiting for client connectting.......\n");
	   //响应客户端连接
	   newfd=accept(fd,(struct sockaddr *)&peer,&size);  
	   //客户端  ip  端口
	   printf("client:  ip:%s   port:%d\n",inet_ntoa(peer.sin_addr),ntohs(peer.sin_port));
	   //建立线程 负责接收客户端数据
	   pthread_create(&tid,NULL,routine,(void*)newfd);
  }
    return 0;
}


2. //并发服务器 创建线程负责数据交互

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include<string.h>
extern int errno;

void *routine(void *arg)
{
   int newfd=(int)arg;
   char buf[100];
   while(1)
   {
       int cnt1=read(newfd,buf,100);
       printf("threadid=%u,fd=%d\n",pthread_self(),newfd);
       write(1,buf,cnt1);
       if(strncmp(buf,"quit",4)==0)
              break;
   }
   printf("threadid %u exit\n",pthread_self());
   close(newfd);
   pthread_exit();
   return NULL;
}
int main()
{
   //socket
   int fd=socket(AF_INET,SOCK_STREAM,0);
   //绑定地址  协议 端口 ip
   struct sockaddr_in servaddr;
   servaddr.sin_family = AF_INET;
   servaddr.sin_port = htons(1234);
   servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
   printf("server:  ip:%s   port:%d\n",inet_ntoa(servaddr.sin_addr),ntohs(servaddr.sin_port));
   int ret=bind(fd,(struct sockaddr *)&servaddr,sizeof(servaddr));
   if(ret<0)
   {
      fprintf(stderr,"error:%s\n",strerror(errno));
      close(fd);
      return -1;
   }
   //服务器监听
   listen(fd,5);
 
   while(1)
   {
	   pthread_t tid;
	   int newfd;
	   struct sockaddr_in peer;
	   socklen_t size=sizeof(peer);
	   printf("waiting for client connectting.......\n");
	   //响应客户端连接
	   newfd=accept(fd,(struct sockaddr *)&peer,&size);  
	   //客户端  ip  端口
	   printf("client:  ip:%s   port:%d\n",inet_ntoa(peer.sin_addr),ntohs(peer.sin_port));
	   //建立线程 负责接收客户端数据
	   pthread_create(&tid,NULL,routine,(void*)newfd);
  }
    return 0;
}


3. 并发服务器 select函数完成IO复用   

   服务器接收多个客户端请求，接收客户端的数据并打印在服务器端  

</pre></blockquote></blockquote><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;"><pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define LISTEN_PORT 1234
#define MAX_CLIENT	5
#define BUFFSIZE	256
int fds[MAX_CLIENT];  //存储连接的文件描述符

int main(int argc, char **argv)
{
	//监听套接字    连接套接字
	int listenfd, newfd;
	// 地址结构   ： 服务器地址信息，客户端地址信息
	struct sockaddr_in servaddr, peeraddr;
	socklen_t addrsize;
					//
	if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		perror("socket");
		exit(1);
	}

	//设置套接字的选项  Address reuse
	//允许在同一个端口启动服务器的多个实例
	int ret;
	int on = 1;
					//   级别：普通套接字　　地址复用
	ret = setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,
					&on, sizeof(int));
	// if ret

	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(LISTEN_PORT);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

	ret = bind(listenfd, (struct sockaddr *)&servaddr,
			sizeof(servaddr));
	// if ret

	ret = listen(listenfd, MAX_CLIENT);
	// if ret

	//文件描述符集
	fd_set rdfds;	// 可读的集合
	struct timeval tv;  //定时

	int maxsockfd;  // rdfds集合中最大文件描述符加１
	maxsockfd = listenfd + 1;
	int i;

	char buff[BUFFSIZE];

	while(1)
	{
		// 初始化文件描述符集合
		FD_ZERO(&rdfds);
		FD_SET(listenfd, &rdfds);  //将listenfd加入rdfds

		for(i = 0; i < MAX_CLIENT; i++)
			if(fds[i] != 0) // 表示对应一个客户端连接
				FD_SET(fds[i], &rdfds); // 添加活动的连接
		// 超时设定
		tv.tv_sec = 30;
		tv.tv_usec = 0;

		puts("no change ........");
		//select 监控fd发生变化
		ret = select(maxsockfd, &rdfds, NULL, NULL, &tv);
		puts("change ..........");
		// ret < 0 : error
		// ret ==0 : timout
		// ret > 0 , IO change

		if(ret < 0)
		{
			perror("select");
			break;
		}
		if(ret == 0)
		{
			printf("time out\n");
			continue;
		}
		// ret > 0
		// new connection
		addrsize = sizeof(peeraddr);
		//服务器响应客户端请求
		if(FD_ISSET(listenfd, &rdfds)) //有客人已经来访，
		{
			newfd = accept(listenfd,
						(struct sockaddr *)&peeraddr,
						&addrsize);  //开门
			// 添加新的ｆｄ到数组中
			for(i = 0; i < MAX_CLIENT; i++){
				if(fds[i] == 0)
				{
					fds[i] = newfd;
					break;
				}
			}

			 // maxsockfd　保证大于集合中的所有文件描述符
			 if(newfd > maxsockfd - 1)
				maxsockfd = newfd + 1;

		}

		// fds[]  ｓｏｃｋｅｔ临时存储
		// rdfds,  FD_SET 集合
		// read data   fds[]
		// 遍历客户端fd  查找是否有可读的fd
		for(i = 0; i < MAX_CLIENT; i++)
		{
			if(FD_ISSET(fds[i], &rdfds))
			{	// can read
				// recv read
				//ret = read(fds[i], buff, BUFFSIZE);
				ret = recv(fds[i], buff, BUFFSIZE, 0);
				//客户端连接关闭，清除ｆｄｓ相应元素
				if(ret <=0 ){
					close(fds[i]);
					FD_CLR(fds[i], &rdfds);
					fds[i] = 0;
				}
				else{
					write(1, buff, ret);
					puts("");
				}

			} // end if
		} // end for
	}// end while


}

4.并发服务器 poll函数完成IO复用 

        
<span style="font-size:10px;font-weight: normal;">#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <sys/poll.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <netdb.h>
#define MYPORT 1234 //连接时使用的端口
#define MAXCLINE 5 //连接队列中的个数
#define BUF_SIZE 256
#define MAXUSER 256
void showclient(struct pollfd fds[])
{
  	int i;
  	printf("client amount:%d\n", conn_amount);

	for(i = 0; i < MAXCLINE; i++)
  	{
  		printf("[%d]:%d ",i,fds[i].fd);
  	}
 		printf("\n\n");
}
int main(int argc, char **argv)
{
  	int sock_fd,new_fd; //监听套接字 连接套接字
  	struct sockaddr_in server_addr; // 服务器的地址信息
  	struct sockaddr_in client_addr; //客户端的地址信息
  	socklen_t sin_size; //当前的连接数
	int conn_amount=0;
  	int yes = 1;
  	char buf[BUF_SIZE];
  	int ret;
  	int i;
  if((sock_fd = socket(AF_INET,SOCK_STREAM, 0))==-1)
  {
    perror("socket");
    exit(1);
  }
  //设置套接口的选项 SO_REUSEADDR 允许在同一个端口启动服务器的多个实例
  //setsockopt的第二个参数SOL SOCKET 指定系统中，解释选项的级别 普通套接字
  //fcntl(sock_fd, F_SETFL, O_NONBLOCK);
  if(setsockopt(sock_fd,SOL_SOCKET, SO_REUSEADDR,&yes, sizeof(int))==-1)
  {
    perror("setsockopt error \n");
    exit(1);
  }
  memset(&server_addr, 0, sizeof(server_addr));
  server_addr.sin_family = AF_INET; //主机字节序
  server_addr.sin_port = htons(MYPORT);
  server_addr.sin_addr.s_addr = htonl(INADDR_ANY);//通配IP
 // memset(server_addr.sin_zero,'\0',sizeof(server_addr.sin_zero));
  if(bind(sock_fd,(struct sockaddr *)&server_addr,sizeof(server_addr)) == -1)
  {
    perror("bind error!\n");
    exit(1);
  }
  if(listen(sock_fd, MAXCLINE)== -1)
  {
    perror("listen error!\n");
    exit(1);
  }

  printf("listen port %d\n", MYPORT);

    struct pollfd fdsr[MAXUSER];
    int maxsock = sock_fd;
 
    conn_amount =0;
    sin_size = sizeof(client_addr);
	/*将数组中的第一个元素设置成监听描述字*/
    fdsr[0].fd = sock_fd;
    //fdsr[0].events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI;
    fdsr[0].events = POLLIN; 
    /*数组中的其它元素将暂时设置成不可用*/
    for(i = 1; i < MAXUSER; i++)
        fdsr[i].fd = -1;
	int nready;
	int recv_bytes;
  while(1){
        //将进程阻塞在poll上
        printf("wait client \n");
        nready = poll(fdsr, maxsock + 1, -1);  // INFTIM
        printf("out\n"); 
        /*先测试监听描述字*/
        if( fdsr[0].revents & POLLIN)
		{
            printf("wait for new connect...\n");
            new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size);
            
            /*将新连接加入到测试数组中*/
            printf("new connect... %d\n", new_fd);
            for(i = 1; i < MAXUSER; i++)
			{
                if(fdsr[i].fd < 0)
				{
                    fdsr[i].fd = new_fd;
                    fdsr[i].events = POLLIN;/*测试条件普通数据可读*/
                    break;
                }
            }
            
            if(i == MAXUSER)
			{
                printf("too many client\n");
				continue;
            }
            if(i > maxsock)
                maxsock = i;
            
            if(--nready <= 0 )
                continue;
           //如果没有可读的描述符了，就重新监听连接
        } 
        /*测试除监听描述字以后的其它连接描述字*/
        for( i = 1; i <= maxsock; i++)
		{
             if(fdsr[i].fd < 0)
                 continue;
             if(fdsr[i].revents & (POLLIN | POLLERR))
			 {
                 memset(buf, 0, BUF_SIZE);
                 recv_bytes = recv(fdsr[i].fd, buf, BUF_SIZE, 0);
                if(recv_bytes < 0)
				 {
                    if( errno == ECONNRESET)
					{ //如果连接断开，就关闭连接，并设当前描述符不可用
                        close(fdsr[i].fd);
                        fdsr[i].fd = -1;
                    }
                    else
                        perror("read error");
                 }
                else if(recv_bytes == 0)
				 { //如果数据读取完毕，关闭连接，设置当前描述符不可用
                    close(fdsr[i].fd);
                    fdsr[i].fd = -1;
                 }
                else
                    printf("newfd = %d : %s\n",fdsr[i].fd, buf);
            }
                        
        }     
		showclient(fdsr);
    }
 } 
</span>

5.客户端测试代码    客户端向服务器发送数据

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
extern int errno;
int main()
{
   
   int fd=socket(AF_INET,SOCK_STREAM,0);
   fprintf(stderr,"client id=%d\n",fd);
   
   struct sockaddr_in servaddr;
   servaddr.sin_family = AF_INET;
   servaddr.sin_port = htons(1234);
   servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
   
   int ret=connect(fd,(struct scokaddr *)&servaddr,sizeof(servaddr));
   if(ret<0)
    {   
       fprintf(stderr,"error:%s\n",strerror(errno));
       close(fd);
       return -1;
    }
   char  buf[100];
   while(1)
   {   
       fgets(buf,100,stdin);
       write(fd,buf,strlen(buf));
       if(strncmp(buf,"quit",4)==0)
       {
          close(fd);
          return 0;
       }
   }
   close(fd);
   return 0;
}


jingli14
关注
专栏目录
网络io与io多路复用select/poll/epoll 服务器并发代码实现
08-29
本文将深入探讨网络I/O的基本概念，以及select、poll和epoll这三种I/O多路复用机制，并通过实际代码示例展示其在服务器并发中的应用。 首先，理解网络I/O。在网络通信中，数据传输通常涉及发送（output）和接收...
IO复用之select poll epoll的总结(推荐)
09-15
IO复用是一种编程技术，允许一个进程监控多个文件描述符，等待它们准备就绪以便进行I/O操作，而不必为每个文件描述符创建单独的线程或进程。这种方法极大地提高了程序的并发性和效率，特别是在处理大量连接请求的...
Linux下的TCP/IP编程----IO复用及IO复用服务端
坚持是一种品质
06-04 4421
在之前我们实现的并发服务端时通过床将多个进程来实现的，这种并实现并发的方式简单方便，但是进程的创建和销毁是很消耗系统资源的，在访问量大时服务器很容易出现资源不够用的情况。除此之外，由于每个进程有独立的内存空间，所以进程间的通讯也相对比较复杂。因此我们可以考虑通过另一种方式来实现服务端的并发服务——IO复用。复用：复用在通讯领域很常见，一般常见”频分复用”,”时分复用”等名词。其实复用就是在一个通信频
高级IO以及IO多路复用（select、poll、epoll网络编程）
qq_61635026的博客
03-09 1119
IO多路复用是一种高效的I/O处理机制，它允许在单个线程中同时监视和处理多个I/O操作，以提高程序的性能和可扩展性。 在传统的阻塞I/O模型中，每个I/O操作都会阻塞整个进程，直到该操作完成。这就意味着如果应用程序需要处理多个并发I/O操作，就需要建立多个线程或者进程来处理它们，这样就会导致系统的开销过高，并且导致可扩展性下降。 使用IO多路复用，应用程序可以将多个I/O操作注册到一个事件的循环中，然后使用一个线程来监视这些操作的状态。当其中任何一个操作就绪时，事件循环就会通知相应的应用程序，来执行相应
网络IO与IO多路复用Select、Poll、ePoll
m0_63428711的博客
05-27 1806
selectpoll和epoll都是针对IO的处理IO事件触发selectpoll和epoll是 Linux 系统中用于处理 I/O 多路复用的三种机制。它们允许一个进程监视多个文件描述符（通常是套接字），以查看它们是否准备好进行读、写或其他操作，而无需为每个文件描述符创建单独的线程或进程select和poll：都是基于轮询的方式来实现I/O多路复用，时间复杂度为O(n)，且都需要将整个文件描述符集合从用户空间复制到内核空间，造成不必要的开销。它们的主要区别在于poll没有文件描述符数量的限制。epoll。
网络编程 - 网络io与多路复用select/ poll/epoll
TOMsmallgood的博客
05-15 858
网络io与多路复用select/poll/epoll
进程、线程、协程、并发、并行、IO多路复用
Flag_ing的博客
05-16 1406
目录 一、什么是IO操作 二、进程、线程、协程 1、进程是资源分配的基本单位 2、线程是任务调度的基本单位 3、协程—由线程创建并全权负责的小弟 三、并行、并发及其与CPU内核数的关系 1、理解并行与并发的区别 2、进程、线程与CPU核数之间的关系 3、同一个进程里的线程可以并行执行吗（满足条件时可以） 四、IO多路复用 五、参考文（zi）献（liao） 我竟然妄想在小小的篇幅下把这四件事讲明白，离谱，但又不太离谱~ 在多线程、多进程、并行、并发这几个概念中，有很多知识点容易让..
Linux网络编程 | 高并发服务器【多进程、线程、select、poll、epoll】
weixin_45926547的博客
02-24 1417
文章目录一、多进程服务器二、多线程服务器三、多路IO转接3.1 select3.1.1 简介3.1.2 常用函数 一、多进程服务器 二、多线程服务器 三、多路IO转接 前面的两个方法都能够实现多个客户端连接一个服务端，但在运行的过程中能发现，它会生成多个进程，每个客户端都会由与之对应的server进程。若应用于网络中，当访问的客户端足够多时，将会造成服务器崩溃；因此，在Linux上我们应该使用内核代替应用程序监视文件； 3.1 select 3.1.1 简介 select能监听的文件描述符个数受限于
42.Linux网络编程--IO多路复用（select poll epoll）
lzs940320的博客
05-10 1946
一. 预备知识 1.Unix五种IO模型 [1] blocking IO - 阻塞IO [2] nonblocking IO - 非阻塞IO [3] IO multiplexing - IO多路复用 [4] signal driven IO - 信号驱动IO [5] asynchronous IO - 异步IO 2.用户空间 / 内核空间 操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。为了保证用户进程不能直接操作内核（kernel），保证.
理解IO复用的三种模式——select、poll、epoll
追求幸福，探索未知的博客
12-07 1541
IO复用是指通过select、poll、epoll等系统调用来监听多个文件描述符的IO事件。当某个文件描述符就绪时，内核会通知用户进程进行IO操作。相比于阻塞IO和非阻塞IO，IO复用可以同时监听多个文件描述符，提高了IO效率。
IO多路复用—多线程网络并发通信 select poll epoll
kaszxc的博客
04-20 546
​ IO 多路转接也称为 IO 多路复用，它是一种网络通信的手段（机制），通过这种方式可以同时监测多个文件描述符并且这个过程是阻塞的，一旦检测到有文件描述符就绪（ 可以读数据或者可以写数据）程序的阻塞就会被解除，之后就可以基于这些（一个或多个）就绪的文件描述符进行通信了。​ 通过这种方式在单线程 / 进程的场景下也可以在服务器端实现并发。
基于io复用的服务器开发例子
11-28
IO复用是一种多路复用技术，它允许一个进程同时等待多个IO操作完成，而无需为每个操作创建单独的线程或进程。这种方法显著提高了资源利用率和系统吞吐量。在Linux系统中，Epoll是实现IO复用的主要机制，相比旧有的...
IO多路复用之select、poll、epoll之间的区别总结
yunfan
07-10 2308
select、poll、epoll都是IO多路复用的机制。IO多路复用就是通过一种机制，让一个进程/线程可以监视多个描述符，一旦某个描述符就绪（一般是读写就绪），能够通知应用程序进行相应的读写操作。I/O复用虽然能同时监听多个文件描述符，当其本质上还是同步IO模型，因为需要在读写事件就绪后程序自己负责进行读写事件的处理，而这个读写过程是阻塞的。如果要实现并发，只能使用多进程/多线程等编程手段了。 ...
实现高并发服务器三种简化模型 线程 进程 IO复用
昨天的你
05-24 547
知识点：UNIX网络编程第四章， 第五章，第六章 多进程模型： #include #include #include #include #include #include #include #include #define SERV_PORT 3000 #define MAXLINE 1024 void str_echo(int sockfd) { ssize_t n; char b
Linux 常用指令
ZH_qaq的博客
09-17 1834
这是本人在备战 CSP 初赛做 Linux 指令题时，心血来潮整理的，希望对大家有帮助。如有错误或有补充，麻烦私信或评论指出。
传奇开服需要多少钱？传奇开服服务器是自己买还是租？
最新发布
携手驰网小林一同探索拥有一台服务器可以做哪些很酷的事情吧~
09-20 560
传奇游戏作为经典怀旧之作，备受人们喜爱。在科技发达的当下，许多人选择自己开服。下面按照开服流程一步一步来分析。
Linux5-echo,＞,tail
2301_80339607的博客
09-15 582
选项-f，例如tail -f test.txt，实时跟踪（如果添加数据，这里立即显示，如果要退出追踪，按Ctrl+c）例如：echo "hello world"，输出hello world。选项-num，例如tail -5 test.txt，查看末尾5行。echo 'pwd'，输出pwd的位置。tail用于查看末尾内容，默认为末尾10行。echo是输出命令，类似printf。例如：tail test.txt。>指把左边内容覆盖到右边。>>把左边内容追加到右边。2.重定向符> >>
VMware安装rustdesk服务器
Morze的博客
09-20 348
首先准备服务器镜像：22.04虚拟机硬件配置选1G RAM 20G ROM就行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值