Select实现多路IO转接实现原理

最新推荐文章于 2022-07-25 15:47:09 发布
最新推荐文章于 2022-07-25 15:47:09 发布
阅读量851 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreams_deng/article/details/104309055
版权

1. 对比

传统多进程、多线程 socket 缺点

server要阻塞 accpet 等待客户端连接、server 阻塞等待read

那么 系统内核提供多路IO selector 来帮助我们解决这个问题

 

  例子： 老板(server)  有一个秘书(select)  当三次握手来的时候c1,秘书接待，告诉老板,
那么老板 启动监听 accpt() 返回一个cfd【 不用阻塞了，来了启动】 给秘书，
c1 conncetin     秘书告诉老板 ，老板返回cfd, 当c1 read的时候，秘密告诉老板，老板处理
    但 c2 三次握手的时候，秘书直接 返回 lff
    
    那么老板可以去做其他事情了，不用阻塞

多路IO Selector提供 函数

       void FD_CLR(int fd, fd_set *set);   --  将一个文件描述符从监听集合中移除
       FD_CLR(4,&rest)      
         
       int  FD_ISSET(int fd, fd_set *set);  -- 判断一个文件描述符是否在监听集合中
       FD_ISSET(4,&rest)
       返回值  在 1  不在 0       
       
       void FD_SET(int fd, fd_set *set);    --- 将待监听的文件描述符，添加到监听集合中
       FD_SET(3,&rest)
       void FD_ZERO(fd_set *set);           --- 清空一个文件描述符集合
       fd_set rest;
       FD_ZERO(&rset)

     int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);
     nfds ：  监听文件描述符中，最大文件秒速符 +1 
   readfds ：  读  文件描述符监听集合     传入、传出参数
   writefds    写  文件描述符监听集合     传入、传出参数     NULL
   exceptfds  异常  文件描述符监听集合    传入、传出参数     NULL 
   
   timeout >0:  设置监听超时时长
           NULL: 阻塞监听
           0   ：非阻塞监听、轮询
           
   返回值   
           >0   所有返回集合(3个)中，满足对应事件的总数
           0    没有满足监听条件的文件描述符
           -1   errno
           
           
  把要监听的 文件描述符放入 fs_set中， 监听内容读 、写 、异常
  
  读+写+异常 总数返回值 

2.多路IO中每一句代码含义：

======================================================================

int i, j, n, nready;

    int maxfd = 0;

    int listenfd, connfd;

    char buf[BUFSIZ];         /* #define INET_ADDRSTRLEN 16 */

    struct sockaddr_in clie_addr, serv_addr;
    socklen_t clie_addr_len;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);  
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family= AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port= htons(SERV_PORT);
    Bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    Listen(listenfd, 128);

server socket 、bind 、list   : 三次握手基础

   fd_set rset, allset;        

定义 rest 、allset 位 运算集合

   

   maxfd = listenfd;

int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);
     nfds ：  监听文件描述符中，最大文件秒速符 +1 
   readfds ：  读  文件描述符监听集合     传入、传出参数
   writefds    写  文件描述符监听集合     传入、传出参数     NULL
   exceptfds  异常  文件描述符监听集合    传入、传出参数     NULL 

    FD_ZERO(&allset);    // 置空 allset 
    FD_SET(listenfd, &allset);             

while (1) {   
        rset = allset;                        

                 // 每次循环时都从新设置select监控信号集 
      nready = select(maxfd+1, &rset, NULL, NULL, NULL);  

// select 函数，如果监听的3号文件描述符有请求，那么保留1，否则值0

      if (nready < 0)   
  perr_exit("select error");

 // 返回集合(3个)中，满足对应事件的总数,返回1
          if (FD_ISSET(listenfd, &rset)) {        

// 判断rest中是否包含3号文件描述符

 clie_addr_len = sizeof(clie_addr);
            connfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addr_len);  

  // select做不了accpet，有请求accept接收，返回通信文件描述符

            FD_SET(connfd, &allset);                            // 向监控文件描述符集合allset添加新的文件描述符connfd,用于监听读

            if (maxfd < connfd)  
                maxfd = connfd;                           // 保存最大文件描述符

            if (0 == --nready)                              
                continue;

  //   nready= 1  那么此时  0 ，回到select 阻塞等待监听

//     如果有2个socket，一个lfc ,一个 cfd,  lfd 执行完毕以后 nready=1， 那么跳出while ,进行下面的 读取数据
        } 

        for (i = listenfd+1; i <= maxfd; i++) {                 

            if (FD_ISSET(i, &rset)) {

// 文件描述符从 0-1024 ， 找到那么 从 rest 中找到 对应文件描述符

                if ((n = Read(i, buf, sizeof(buf))) == 0) {    

 //  当client关闭链接时,服务器端也关闭对应链接 
                    Close(i);
                    FD_CLR(i, &allset);  

   //  解除select对此文件描述符的监控                   

                } else if (n > 0) {

                    for (j = 0; j < n; j++)
                        buf[j] = toupper(buf[j]);

      // 进行数据读写
                    Write(i, buf, n);
                }
            }
        }
    }

    Close(listenfd);

======================================================================

多路IO总图：

3.具体代码实现

原理：就是用一个allset ，把有文件描述符作为角标需要监听的的位置1，然后放入seletor监听，最后返回allset，如果没有请求的文件描述符置0，最后从allset 中找出 标志1 的文件描述符 值【数组下标】，进行操作

wrap.h

#ifndef __WRAP_H_
#define __WRAP_H_

void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);

#endif

wrap.c

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

void perr_exit(const char *s)
{
	perror(s);
	exit(-1);
}

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
	int n;

again:
	if ((n = accept(fd, sa, salenptr)) < 0) {
		if ((errno == ECONNABORTED) || (errno == EINTR))
			goto again;
		else
			perr_exit("accept error");
	}
	return n;
}

int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

	if ((n = bind(fd, sa, salen)) < 0)
		perr_exit("bind error");

    return n;
}

int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

	if ((n = connect(fd, sa, salen)) < 0)
		perr_exit("connect error");

    return n;
}

int Listen(int fd, int backlog)
{
    int n;

	if ((n = listen(fd, backlog)) < 0)
		perr_exit("listen error");

    return n;
}

int Socket(int family, int type, int protocol)
{
	int n;

	if ((n = socket(family, type, protocol)) < 0)
		perr_exit("socket error");

	return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
	ssize_t n;

again:
	if ( (n = read(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
	ssize_t n;

again:
	if ( (n = write(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

int Close(int fd)
{
    int n;
	if ((n = close(fd)) == -1)
		perr_exit("close error");

    return n;
}

/*参三: 应该读取的字节数*/
ssize_t Readn(int fd, void *vptr, size_t n)
{
	size_t  nleft;              //usigned int 剩余未读取的字节数
	ssize_t nread;              //int 实际读到的字节数
	char   *ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		if ((nread = read(fd, ptr, nleft)) < 0) {
			if (errno == EINTR)
				nread = 0;
			else
				return -1;
		} else if (nread == 0)
			break;

		nleft -= nread;
		ptr += nread;
	}
	return n - nleft;
}

ssize_t Writen(int fd, const void *vptr, size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;

	ptr = vptr;
	nleft = n;
	while (nleft > 0) {
		if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
			if (nwritten < 0 && errno == EINTR)
				nwritten = 0;
			else
				return -1;
		}

		nleft -= nwritten;
		ptr += nwritten;
	}
	return n;
}

static ssize_t my_read(int fd, char *ptr)
{
	static int read_cnt;
	static char *read_ptr;
	static char read_buf[100];

	if (read_cnt <= 0) {
again:
		if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
			if (errno == EINTR)
				goto again;
			return -1;
		} else if (read_cnt == 0)
			return 0;
		read_ptr = read_buf;
	}
	read_cnt--;
	*ptr = *read_ptr++;

	return 1;
}

ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
	ssize_t n, rc;
	char    c, *ptr;

	ptr = vptr;
	for (n = 1; n < maxlen; n++) {
		if ( (rc = my_read(fd, &c)) == 1) {
			*ptr++ = c;
			if (c  == '\n')
				break;
		} else if (rc == 0) {
			*ptr = 0;
			return n - 1;
		} else
			return -1;
	}
	*ptr  = 0;

	return n;
}

client.c

/* client.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    int sockfd, n;

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr.s_addr);
    servaddr.sin_port = htons(SERV_PORT);

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    printf("------------connect ok----------------\n");

    while (fgets(buf, MAXLINE, stdin) != NULL) {
        Write(sockfd, buf, strlen(buf));
        n = Read(sockfd, buf, MAXLINE);
        if (n == 0) {
            printf("the other side has been closed.\n");
            break;
        }
        else
            Write(STDOUT_FILENO, buf, n);
    }
    Close(sockfd);

    return 0;
}

server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <ctype.h>

#include "wrap.h"

#define SERV_PORT 6666

int main(int argc, char *argv[])
{
    int i, j, n, nready;

    int maxfd = 0;

    int listenfd, connfd;

    char buf[BUFSIZ];         /* #define INET_ADDRSTRLEN 16 */

    struct sockaddr_in clie_addr, serv_addr;
    socklen_t clie_addr_len;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);  
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family= AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port= htons(SERV_PORT);
    Bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    Listen(listenfd, 128);
    

    fd_set rset, allset;                            /* rset 读事件文件描述符集合 allset用来暂存 */

    maxfd = listenfd;

    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);                                  /* 构造select监控文件描述符集 */

    while (1) {   
        rset = allset;                                          /* 每次循环时都从新设置select监控信号集 */
        nready = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nready < 0)
            perr_exit("select error");

        if (FD_ISSET(listenfd, &rset)) {                        /* 说明有新的客户端链接请求 */

            clie_addr_len = sizeof(clie_addr);
            connfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addr_len);       /* Accept 不会阻塞 */

            FD_SET(connfd, &allset);                            /* 向监控文件描述符集合allset添加新的文件描述符connfd */

            if (maxfd < connfd)
                maxfd = connfd;

            if (0 == --nready)                                  /* 只有listenfd有事件, 后续的 for 不需执行 */
                continue;
        } 

        for (i = listenfd+1; i <= maxfd; i++) {                 /* 检测哪个clients 有数据就绪 */

            if (FD_ISSET(i, &rset)) {

                if ((n = Read(i, buf, sizeof(buf))) == 0) {    /* 当client关闭链接时,服务器端也关闭对应链接 */
                    Close(i);
                    FD_CLR(i, &allset);                        /* 解除select对此文件描述符的监控 */

                } else if (n > 0) {

                    for (j = 0; j < n; j++)
                        buf[j] = toupper(buf[j]);
                    Write(i, buf, n);
                }
            }
        }
    }

    Close(listenfd);

    return 0;
}

4. 优化版：

使用 client 数组把监听到的套接字描述符保存起来，maxi client 有文件描述符数据部分的长度

select优缺点：

缺点：监听上限收到文件描述符限制。最大1024

          检测满足条件的fd,自己添加业务逻辑提高小，提高编码难度

有点：跨平台，出现的早，win、linux、macos、unix

wrap.h

#ifndef __WRAP_H_
#define __WRAP_H_

void perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);

#endif

wrap.c

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

void perr_exit(const char *s)
{
	perror(s);
	exit(-1);
}

int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
	int n;

again:
	if ((n = accept(fd, sa, salenptr)) < 0) {
		if ((errno == ECONNABORTED) || (errno == EINTR))
			goto again;
		else
			perr_exit("accept error");
	}
	return n;
}

int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

	if ((n = bind(fd, sa, salen)) < 0)
		perr_exit("bind error");

    return n;
}

int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
    int n;

	if ((n = connect(fd, sa, salen)) < 0)
		perr_exit("connect error");

    return n;
}

int Listen(int fd, int backlog)
{
    int n;

	if ((n = listen(fd, backlog)) < 0)
		perr_exit("listen error");

    return n;
}

int Socket(int family, int type, int protocol)
{
	int n;

	if ((n = socket(family, type, protocol)) < 0)
		perr_exit("socket error");

	return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
	ssize_t n;

again:
	if ( (n = read(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
	ssize_t n;

again:
	if ( (n = write(fd, ptr, nbytes)) == -1) {
		if (errno == EINTR)
			goto again;
		else
			return -1;
	}
	return n;
}

int Close(int fd)
{
    int n;
	if ((n = close(fd)) == -1)
		perr_exit("close error");

    return n;
}

/*参三: 应该读取的字节数*/
ssize_t Readn(int fd, void *vptr, size_t n)
{
	size_t  nleft;              //usigned int 剩余未读取的字节数
	ssize_t nread;              //int 实际读到的字节数
	char   *ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		if ((nread = read(fd, ptr, nleft)) < 0) {
			if (errno == EINTR)
				nread = 0;
			else
				return -1;
		} else if (nread == 0)
			break;

		nleft -= nread;
		ptr += nread;
	}
	return n - nleft;
}

ssize_t Writen(int fd, const void *vptr, size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;

	ptr = vptr;
	nleft = n;
	while (nleft > 0) {
		if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
			if (nwritten < 0 && errno == EINTR)
				nwritten = 0;
			else
				return -1;
		}

		nleft -= nwritten;
		ptr += nwritten;
	}
	return n;
}

static ssize_t my_read(int fd, char *ptr)
{
	static int read_cnt;
	static char *read_ptr;
	static char read_buf[100];

	if (read_cnt <= 0) {
again:
		if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
			if (errno == EINTR)
				goto again;
			return -1;
		} else if (read_cnt == 0)
			return 0;
		read_ptr = read_buf;
	}
	read_cnt--;
	*ptr = *read_ptr++;

	return 1;
}

ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
	ssize_t n, rc;
	char    c, *ptr;

	ptr = vptr;
	for (n = 1; n < maxlen; n++) {
		if ( (rc = my_read(fd, &c)) == 1) {
			*ptr++ = c;
			if (c  == '\n')
				break;
		} else if (rc == 0) {
			*ptr = 0;
			return n - 1;
		} else
			return -1;
	}
	*ptr  = 0;

	return n;
}

client.c

/* client.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 6666

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;
    char buf[MAXLINE];
    int sockfd, n;

    if (argc != 2) {
        printf("Enter: ./client server_IP\n");
        exit(1);
    }

    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
    servaddr.sin_port = htons(SERV_PORT);

    Connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    printf("------------connect ok----------------\n");

    while (fgets(buf, MAXLINE, stdin) != NULL) {
        Write(sockfd, buf, strlen(buf));
        n = Read(sockfd, buf, MAXLINE);
        if (n == 0) {
            printf("the other side has been closed.\n");
            break;
        }
        else
            Write(STDOUT_FILENO, buf, n);
    }
    Close(sockfd);

    return 0;
}

server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <ctype.h>

#include "wrap.h"

#define SERV_PORT 6666

int main(int argc, char *argv[])
{
    int i, j, n, maxi;

    int nready, client[FD_SETSIZE];                 /* 自定义数组client, 防止遍历1024个文件描述符  FD_SETSIZE默认为1024 */
    int maxfd, listenfd, connfd, sockfd;
    char buf[BUFSIZ], str[INET_ADDRSTRLEN];         /* #define INET_ADDRSTRLEN 16 */
	//FD_SETSIZE 1024 BUFSIZ 8192  INET_ADDRSTRLEN 16  系统定义的宏  

    struct sockaddr_in clie_addr, serv_addr;
    socklen_t clie_addr_len;
    fd_set rset, allset;                            /* rset 读事件文件描述符集合 allset用来暂存 */

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family= AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port= htons(SERV_PORT);

    Bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    Listen(listenfd, 128);

    maxfd = listenfd;                                           /* 起初 listenfd 即为最大文件描述符 */

    maxi = -1;                                                  /* 将来用作client[]的下标, 初始值指向0个元素之前下标位置 */
    for (i = 0; i < FD_SETSIZE; i++)
        client[i] = -1;                                         /* 用-1初始化client[] */

    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);                                  /* 构造select监控文件描述符集 */

    while (1) {   
        rset = allset;                                          /* 每次循环时都从新设置select监控信号集 */

        nready = select(maxfd+1, &rset, NULL, NULL, NULL);  //2  1--lfd  1--connfd
        if (nready < 0)
            perr_exit("select error");

        if (FD_ISSET(listenfd, &rset)) {                        /* 说明有新的客户端链接请求 */

            clie_addr_len = sizeof(clie_addr);
            connfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addr_len);       /* Accept 不会阻塞 */
            printf("received from %s at PORT %d\n",
                    inet_ntop(AF_INET, &clie_addr.sin_addr, str, sizeof(str)),
                    ntohs(clie_addr.sin_port));

			// 1024
            for (i = 0; i < FD_SETSIZE; i++)
                if (client[i] < 0) {                            /* 找client[]中没有使用的位置 */
                    client[i] = connfd;                         /* 保存accept返回的文件描述符到client[]里 */
                    break;
                }

            if (i == FD_SETSIZE) {                              /* 达到select能监控的文件个数上限 1024 */
                fputs("too many clients\n", stderr);
                exit(1);
            }

            FD_SET(connfd, &allset);                            /* 向监控文件描述符集合allset添加新的文件描述符connfd */

            if (connfd > maxfd)
                maxfd = connfd;                                 /* select第一个参数需要 */

            if (i > maxi)
                maxi = i;                                       /* 保证maxi存的总是client[]最后一个元素下标 */

            if (--nready == 0)
                continue;
        } 

        for (i = 0; i <= maxi; i++) {                               /* 检测哪个clients 有数据就绪 */

            if ((sockfd = client[i]) < 0)
                continue;
            if (FD_ISSET(sockfd, &rset)) {

                if ((n = Read(sockfd, buf, sizeof(buf))) == 0) {    /* 当client关闭链接时,服务器端也关闭对应链接 */
                    Close(sockfd);
                    FD_CLR(sockfd, &allset);                        /* 解除select对此文件描述符的监控 */
					// 移除了 从数组中移除
                    client[i] = -1;
                } else if (n > 0) {
                    for (j = 0; j < n; j++)
                        buf[j] = toupper(buf[j]);
                    Write(sockfd, buf, n);
                    Write(STDOUT_FILENO, buf, n);
                }
				// 如果只有一个 ，跳出循环
                if (--nready == 0)
                    break;                                          /* 跳出for, 但还在while中 */
            }
        }
    }
    Close(listenfd);
    return 0;
}

 

5. 其他： 

   epoll优点现对于poll和select
  poll是在select上改的，但是poll是一个半成品
  
  epoll是linux下多路复用IO接口select/poll增强版,它能显著提高程序在大量并发连接中只有少量活跃的
  情况下系统cpu的利用率
  因为它会复用描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被监听文件描述符集合，
  另外一点原因是获取事件的时候,它无需遍历整个被监听的描述符集合，主要遍历那些被内核IO事件异步唤醒而加入
  Ready队列的描述符集合即可
  
  epoll只能在linux下使用

  epoll实现原理，把lfd,cfd挂在在红黑树上，并且红黑树的每一个节点都配置一个结构体，用于保存lfd,cfd,通过epoll_wait函数监听，返回带有文件描述符的数组，然后对应的文件描述符进行accpet、read操作


  开源网络通信库： libevent, 跨平台
  
  源码安装： 参数README
  ./configure      检查安装环境,生成makefile
  make             生成.o 和 可执行文件
  sudo make install 将必要的资源cp到系统指定目录

 

龙德施泰.冯.置
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多路I/O转接服务器
log_Li的博客
07-16 190
多路I/O转接服务器多路I/O转接服务器selectpselectpollppollepoll基础API 多路I/O转接服务器 多路IO转接服务器也叫做多任务IO服务器。该类服务器实现的主旨思想是，不再由应用程序自己监视客户端连接，取而代之由内核替应用程序监视文件。 主要使用的方法有三种：select，poll，epoll select select能监听的文件描述符个数受限于FD_SETSIZE,一般为1024，单纯改变进程打开的文件描述符个数并不能改变select监听文件个数 解决1024以下客户端时
select和epoll实现多路复用.zip
05-20
实验报告`epoll和select实现多路复用.docx`应该详细记录了实验的步骤、代码实现、测试过程以及分析结果。通过阅读报告，你可以深入理解这两种多路复用方法在实际应用中的差异，以及它们对系统资源的利用情况。 总结...
linux编程:多路转接复用IO之select模型
qq_42613519的博客
02-16 267
linux编程:多路转接复用IO之select模型 多路转接IO概念 描述的是转接IO，就是对大量的描述符的IO状态进行监控，能够让程序知道哪个描述符IO是就绪的，可以进行IO操作，直接让程序针对就绪描述符进行IO操作，提高效率（更多用于网络通信服务器)。 IO就绪状态 可读状态:套接字接收缓冲区中，数据大小大于低水位标记（默认-1字节) 可写状态:套接字发送缓冲区中，剩余空间大小大于低水位标记（默认-1字节) 异常状态 select模型 实现思路就是在内核中轮询遍历所有监控的描述符，判断IO
多路IO转接服务器——select模型
weixin_40547071的博客
04-12 251
多路IO转接服务器——select模型，相对于我之前博客里面的多线程和多进程实现多客户端通信，由于不用创建多个线程、多个进程来实现并发了，没有线程、进程回收问题。只使用select来监听所有的文件描述符，资源占用的就少了。select模型就是把要监听的文件描述符或者称为套接字，全都放到一个集合，调用select函数之后会一直监视集合中哪些文件描述符可读，哪些可写，如果有可读的文件描述符那就去读数据...
多路I/O转接服务器(一)：select以及其两种实现方式
i96jie的博客
04-17 311
多路IO转接服务器也叫做多任务IO服务器。该类服务器实现的主旨思想是，不再由应用程序自己监视客户端连接。 通过三个例子，来举例： 例一例二是在windows平台下的，例三兼容多平台。 1、无select的socket编程 #define FD_SETSIZE 1024 #include <WinSock2.h> #include <iostream> #inclu...
SOCKET网络编程四：SELECT单进程并发服务器
mazi的博客
02-15 735
五种IO模型： 阻塞IO：recv接收缓冲区有数据后，就会解除阻塞。 非阻塞IO：忙等待fcntl(fd,F_SETFL,flag|O_NONBLOCK) IO复用（select和poll） 信号驱动IO 异步IO ...
windows下多路复用IO（select,WSAAsyncSelect,WSAEventSelect）
11-17
本篇文章将深入探讨三种在Windows环境下实现多路复用I/O的主要方法：`select`、`WSAAsyncSelect`和`WSAEventSelect`。 ### 1. `select`函数 `select`是跨平台的I/O多路复用机制，不仅在Windows中可用，也在大多数...
select io多路复用
12-23
自己写的代码,通过select实现 io多路复用.希望对大家学习网络编程有帮助
IO多路复用之select全面总结(必看篇)
01-10
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取，它就通知该进程。IO多路复用适用如下场合： （1）当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。 （2）当一个客户...
Python通过select实现异步IO的方法
09-21
`select`模块是Python中用于实现异步I/O的一个核心工具，特别适合于处理多个套接字或其他文件描述符的事件。 `select`函数是`select`模块的核心，其基本语法如下： ```python select.select(read_list, write_list...
select函数
weixin_43224582的博客
11-13 264
select函数 函数原型： int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); 参1： 所监听的所有文件描述符中，最大的文件描述符+1，fd4+1 参2/3/4: 所监听的文件描述符“可读”事件。readfds(); 所监听的文件描述符“可写”...
Linux网络编程5——多路IO转接服务器
HuanBianCheng27的博客
07-25 404
学习视频链接黑马程序员-Linux网络编程_哔哩哔哩_bilibilihttps。
Xilinx FPGA SelectIO串并转换IP核使用笔记
xunqijinghua的专栏
08-01 1万+
IP核参数配置总结页：串行输入，8bit并行输出，single-end信号，速率为SDR，IO时钟驱动缓冲包括了BUFIO\BUFG等原语。 第一步：Example Design工程。FPGA的仿真重要性远大于RTL代码，所以本次从simulation的测试文件开始，即 module selectio_wiz_0_tb (); // From the system into the d...
Linux网络编程(3)
PT的博客
04-01 392
1、主动发起关闭连接 一开始是关闭状态，主动发起连接段发送SYN信号，进入SYN_SENT(主动打开状态)，发送ACK和SYN信号，接收发送端返回的ACK信号，此时三次握手建立完毕，进入ESTABLISHED(数据传输状态) 一端发送FIN标志，进入FIN_WAIT_1状态，接收对端发送过来的ACK后进入FIN_WAIT2状态，(半关闭状态)，主动发起端接收对端发来的FIN...
select()函数以及FD_ZERO、FD_SET、FD_CLR、FD_ISSET
kouriba
12-22 1556
select函数用于在非阻塞中，当一个套接字或一组套接字有信号时通知你，系统提供select函数来实现多路复用输入/输出模型，原型： #include sys/time.h&gt; #include unistd.h&gt; int select(int maxfd,fd_set *rdset,fd_set *wrset,fd_set *exset,struct timeva...
fd_set 用法 socket
热门推荐
ccjjyy的专栏
11-12 1万+
select()函数主要是建立在fd_set类型的基础上的。fd_set（它比较重要所以先介绍一下）是一组文件描述字(fd)的集合，它用一位来表示一个fd（下面会仔细介绍），对于fd_set类型通过下面四个宏来操作：      fd_set set;    FD_ZERO(&set);       /* 将set清零使集合中不含任何fd*/    FD_SET(fd, &set);    /* 将fd加入set集合 */    FD_CLR(fd, &set);    /* 将fd从set集合中清除 *
Socket编程实践(10) --select的限制与poll的使用
weixin_30780649的博客
03-14 184
select的限制用select实现的并发服务器，能达到的并发数一般受两方面限制:1)一个进程能打开的最大文件描述符限制。这可以通过调整内核参数。可以通过ulimit-n(number)来调整或者使用setrlimit函数设置，但一个系统所能打开的最大数也是有限的，跟内存大小有关，可以通过cat/proc/sys/fs/file-max查看/**示例: getrlimit/setrlim...
socket select多路连接，及fd_set用法
dinghuiyang的博客
07-19 1716
fd_set用法：https://blog.csdn.net/w00347190/article/details/100972645 /*********************************** fd_set 用法： void FD_SET(int fd, fd_set *fdset); void FD_CLR(int fd, fd_set *fdset); void FD_ISSET(int fd, fd_set *fdset); void FD_ZERO(fd_set *fd.
五种IO模型简介以及IO多路转接之select
rushing的博客
07-12 1908
五种IO模型的简单学习和多路转接之select服务器的实现
多路复用IO机制实现原理
最新发布
05-16
多路复用（Multiplexing）是指通过一种机制，使多个独立的输入、输出流（通道）在一个物理通信线路上同时传输数据。在计算机网络编程中，通过多路复用技术可以实现同时监听多个网络连接，从而提高程序的并发性和吞吐量。 常见的多路复用IO机制有select、poll、epoll等。这些机制的实现原理类似，都是基于操作系统提供的文件描述符（file descriptor）和事件通知机制。 具体来说，多路复用IO的实现过程如下： 1. 创建一个等待队列，用来存放需要进行IO操作的文件描述符。 2. 把多个文件描述符添加到等待队列中，同时注册感兴趣的事件（如读、写、异常等）。 3. 调用多路复用函数（如select、poll、epoll），等待事件的发生。 4. 当有事件发生时，多路复用函数返回，程序通过遍历等待队列，找到发生事件的文件描述符，并进行相应的IO操作。 5. 重复执行上述步骤，实现多路复用IO的功能。 总的来说，多路复用IO机制可以实现高效的并发IO处理，可以极大地提升程序的性能和响应速度。但是需要注意的是，不同的多路复用机制在实现上有一些差异，需要根据具体情况选择合适的机制。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值