网络编程（6）-----IO模型以及多路复用的基本原理

已于 2023-12-08 11:20:41 修改
阅读量306 收藏 6
点赞数 8
文章标签： 网络
于 2023-12-06 15:38:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42007446/article/details/134831176
版权

IO模型

阻塞I/O模式：

1.阻塞I/O模式是最普通使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O.

2.缺省情况下，套接字建立后所处于的模式就是阻塞I/O模式。

读阻塞：

以read函数为例
进程调用read函数从套接字上读取数据，当套接字的接收缓冲区中还没有数据可读，函数read将发生阻塞。
它会一直阻塞下去，等待套接字的接收缓冲区中有数据可读。
经过一段时间后，缓冲区内接收到数据，于是内核便去唤醒该进程，通过read访问这些数据。
如果在进程阻塞过程中，对方发生故障，那这个进程将永远阻塞下去。

写阻塞：

在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下。
这时，写操作不进行任何拷贝工作，将发生阻塞一量发送缓冲区内有足够的空间，内核将唤醒进程，将数据从用户缓冲区中拷贝到相应的发送数据缓冲区
UDP不用等待确认，没有实际的发送缓冲区，所以UDP协议中不存在发送缓冲区满的情况，在UDP套接字上执行的写操作永远都不会阻塞

非阻塞I/O模式：

当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核:“当我请求的I/0操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。
当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读(称做polling )

应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU源的操作。
这种模式使用中不普遍

多路复用I\O

应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的;
若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间:若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂:
比较好的方法是使用I/0多路复用。其基本思想是:
- 先构造一张有关描述符的表，然后调用一个函数。当这些文件描述符中的一个或多个已准备好进行I/0时函数才返回。
函数返回时告诉进程那个描述符已就绪，可以进行I/0操作。

基本常识：

linux中每个进程默认情况下，最多可以打开1024个文件，最多有1024个文件描述
文件描述符的特点:
1.非负整数
2.从最小可用的数字来分配
3.每个进程启动时默认打开0，1，2 三个文件描述符

多路复用针对不止套接字fd,也针对普通的文件描述fd

1.把关心文件描述符加入到集合中（fd_set） 

void FD_ZERO():清零 集合

void FD_SET():加入集合

void FD_CLR();从集合中删除

void FD_ISSET();

   2.调用select（）/poll( )函数去监控集合fd-set中那些文件描述符，等待集合中的一个或多个文件描述符有数据。

 int select（）

select退出后：集合表示有数据的集合

if(FD_ISSET(fd,)){   }

(1)若是监听套接字上有数据：则有新客户端连接，则accept().

(2)若是已建立连接的套接字上有数据，则去读数据。

3.当有数据时，退出select（）阻塞

4.依次判断哪个文件描述符有数据

5.依次处理那有数据的文件描述符的数据


int main(void)
{

    fd_set rset;
    int maxfd = -1;
    fd = socket(....);
    bind(fd,...);
    listen(fd,....);
while(1){
    maxfd = fd;
    FD_ZERO(&rset);
    
    FD_SET(fd,&rset);
    //依次把已经建立好连接fd加入到集合中，记录下来最大的文件描述符maxfd
    //....
#if 0 
    select(maxfd+1,&rset,NULL,NULL,NULL);
#else
    tout.tv_sec = 5;
    tout.tv_usec = 0;
    select(maxfd+1,&rset,NULL,NULL,&tout);
#endif
    if(FD_ISSET(fd,&rset))
    {
        newfd = accept(fd,....);
    }
    //依次判断已建立连接的客户端是否有数据
    //...FIXME
    
 }


    return 0;

}

1.select()函数里面的各个文件描述符fd_set集合的参数在select( )前后发生了变化:

前:表示关心的文件描述符集合

后:有数据的集合(如不是在超时还回情况下)
2.那么究竟是谁动了fd_set集合的奶酪?

答曰: kernel

/*UDP demo*/
/*usage:
*./client serv_ip serv_port
*/
 
void usage(char *s)
{
    printf("\nthis is udp demo!\n");
    printf("\n usage:\n\t%s serv_ip serv_port",s);
    printf("\n\t serv_ip:udp server ip address");
    printf("\n\t serv_port:udp server port\n\n");
}
 
int main(int argc,char *argv[])
{
    int fd = -1;
    int port = SERV_PORT;
 
    port = atoi(argv[2]);
    if(port < 0 ||(port > 0 && port < 5000))
    {
        usage(argv[0]);
        exit(1);    
    }
 
    struct sockaddr_in sin;
    /*1.创建socket fd*/
    if(argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    /*1.创建socket fd*/
    if(fd = socket(AF_INET,SOCK_DGRAM,0)<0){ //UDP编程
        perror("socket");
        exit(1);
    }
 
    /*2.1填充struct sockaddr_in 结构体变量*/
    bzero(&sin,sizeof(sin));
 
    sin.sin_family = AF_INET;
    sin.sin_port = htons(SERV_PORT);  //网络字节序端口号
    
    /*2.2让服务器程序能绑定在任意IP上*/
#if 0
    sin.sin_addr.s_addr = hton1(INADDR_ANY);
#else
    if(inet_pton(AF_INET,argv[1],(void *)&sin.sin_addr)! =1)
    {
        perror("inet_pton");
        exit(1);
    }
#endif
#if 0 
    char buf[BUFSIZ];
    while(1){
        bzero(buf,BUFSIZ);
        if(fgets(buf,BUFSIZ-1,stdin) == NULL){
            perror("fgets");
            continue;
        }
        sendto(fd,buf,strlen(buf),0,(struct sockaddr *)&sin,sizeof(sin));
        if(!strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)))   //用户输入了quit字符
        {
            printf("client is exited!\n");
            break;
        }
#else
    int ret = -1;
    fd_set rset;
    sruct timeval;
    int maxfd = -1;
    while(1){
        FD_SERO(&rset);
        FD_SET(0,&rset);
        FD_SET(fd,&rset);
        maxfd = fd;
        
        tout.tv_sec = 5;
        tout.tv_usec = 0;
    
        select(maxfd+1,&rset,NULL,NULL,&tout);
        if(FD_ISSET(0,&rset))
        {
            //标准键盘上有输入
            //读取键盘输入，发送到网络套接字fd
            //。。。FIXME!
            bzero(buf,BUFSIZ);
            do{
                ret =  read(0,buf,BUFSIZ-1);
               }while(ret < 0 && EINTER == errno);
                if(ret < 0){
                       perror("read");
                       continue; 
                }
                if(!ret) continue;  /*服务器关闭*/
                if(write(fd,buf,strlen(buf)<0))
                {
                    perror("write() to socket");
                    continue;
                }
            
        }
        if(FD_ISSET(0,&rset))
        {
            //服务器给发送过来的数据
            //读取套接字数据，处理
            bzero(buf,BUFSIZ);
            do{
                ret =  read(0,buf,BUFSIZ-1);
               }while(ret < 0 && EINTER == errno);
                if(ret < 0){
                       perror("read");
                       continue; 
                }
                if(!ret) continue;  /*服务器关闭*/                
    
                if(!strncasecmp(buf,QUIT_STR,strlen(QUIT_STR)))   //用户输入了quit字符
                {
                    printf("client is exited!\n");
                    break;
                }
        }
    }   
    }
    close(fd);
 
}
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netint/ip.h>
#include <errno.h>
#include <pthread.h>
 
 
void usage(char *s)
{
    printf("%s serv_ip serv_port",s);
    printf("\n\t serv_ip: server ip address");
    printf("\n\t serv_port: server port(>5000)\n\t");
 
}
 
 
#define SERV_PORT 5001
#define SERV_IP_ADDR "192.168.7.246"  //服务器地址
#define BACKLOG 5                     //backlog同时允许几路客户端和服务器进行正在连接的过程（正在三次握手）一般填5，测试得知，ARM最大为8
#define QUIT_STR  "quit"
 
void cli_data_handle(void *arg);
void sig_child_hanle(int signo)
{
       if(SIGCHLD == signo)
       {
            waitpid(-1,NULL,WNOHANG);
       }
 
 
}
 
 
 
 
 
 
int  main(int argc,char **argv)
{
    int fd =-1;
    short port;
    struct socke_in sin;
    signal(SIGCHLD,sig_child_handle);
 
 
 
 
 
 
   if(argc != 3)
    {
        usage(argv[0]);
exit(1);
    }
    port = atoi(argv[2]);
    if(port<5000) 
    {
        usage(argv[0]);
        exit(1);
    }
 
 
   /*1.创建socket fd*/
   if((fd = socket(AF_INET,SOCK_STREAM,0))<0)
   {
        perror("socket");
        exit(1);
    }
  /*优化4：允许绑定地址快速重用*/
      int b_reuse = 1;
      setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&b_reuse,sizeof(int));
 
    /*2绑定*/
    /*2.1填充struct sockaddr_in结构体变量*/
    bzero(&sin,sizeof(sin));
    sin.sin_family = AF_INET;   //IPV4
    sin.sin_port = htons(port);   //网络字节序的端口号
/*优化1：让服务器程序能绑定在任意的IP上*/
#if 1
    sin.sin_addr.s_addr = hton1(INADDY_ANY);  //点分形式的IP地址，结果为#32整数
#else
    if(inet_pton(AF_INET,argv[1],(void *)&sin.sin_addr.s_addr)!=1)
    {
       perror("inet_pton");
       exit(1);
    }
#endif
     /*2.2绑定*/
    if(bind(fd,(struct sockaddr *)&sin,sizeof(sin)) < 0 )
    {
           perror("bind");
           exit(1);
     }  
    //如果是IPV6编程呢个，要使用struct sockaddr_in6结构体（详细情况请参考man 7 ipv6 ）,通常更通用的方法可以通过struct sockaddr_storage来编程
 
    /*3.调用listen()把主动套接字变成被动套接字*/
    
    if(listen(fd,BACKLOG)<0)
    {
        perror("listen");
        exit(1);
 
   }                
    /*4.阻塞等待客户端连接请求*/
 
# if 0 
   /*优化3：用多进程/多线程处理已经建立好连接的客户端数据*/
   pthread_t tid;
   struct sockaddr_in cin;
   socklen_t addrlen = sizeof(cin);
   while(1){
        pid_t pid = -1;
      if((newfd = accept(fd,(struct sockaddr *)&cin,&addrlen))< 0)
        {
            perror("accept");
            exit(1);
        }
       char ipv4_addr[16];
       if(!inet_ntop(AF_INET,(void * )&cin.sin_addr,ipv4_addr,sizeof(cin))){
        perror("inet_ntop");
        exit(1);
    }
    printf("client(%s:%d)  is connected!",ipv4_addr,htons(cin.sin_port));
    pthread_create(&tid,NULL,(void *)cli_data_handle,(void *)&newfd);
 
}
#else
    struct sockaddr_in cin;
    socklen_t addrlen = sizeof(cin);
    while(1){
    if ((newfd = accept(fd,(struct sockaddr *)&cin,&addrlrn))<0){
        perror("accept");
        break;    
    }
    /*创建一个子进程用于处理已建立连接的客户的交流数据*/
    if((pid = fork()) < 0)
    {
        perror("fork");
        break;
    }
    if(0 == pid)//子进程
    {
        close(fd);
        char ipv4_addr[16];
        if(!inet_ntop (AF_INET,(void *)&cin.sin_addr,ipv4_addr,sizeof(cin)))
        {
            perror("inet_ntop");
            exit(1);
        }
        printf("client(%s:%d) is connected!\n",ipv4_addr,ntohs(cin.sin_port));
        cli_data_handle(&newfd);
        return 0;
    }else{
        //实际上此处pid>0,父进程中
        close(newfd);
    }
 
 
 
 
 
}
 
#endif
   close(fd);
   return 0;
}
 #define SERV_RESP_STR "Server:"
void cli_data_handle(void * arg)
{

    int newfd = *(int *)arg;
    printf("handler thread: newfd = %d\n",newfd);
    int ret = -1;
    char buf[BUFSIZ];
    char resp_buf[BUFSIZ];
    while(1){
        bzero(buf,BUFSIZ);
        do{
            ret = read(newfd,buf,BUFSIZ-1);
         }while(ret<0 &&EINTR == errno);
        if(ret < 0)
        {
            perror("read");
            exit(1);
        }
        if(!ret)  //对方已关闭
        {
            break;
        }
        printf("receive data:  %s\n",buf);
        bzero(resp_buf,BUFFSIZ+10);
        strncpy(resp_buf,SERV_RESP_STR,strlen(SERV_RESP_STR));
        strcat(resp_buf,buf);
        do{
            write(newfd,resp_buf,strlen(resp_buf));
        }while(ret < 0 && EINTR == errno);
        if(!strncasecmp(buf,QUIT_STR,strlen(QUIT_STR))){    //用户输入了quit字符
                   printf("client(fd%d) is exiting \n",newfd);
                   break;
         }
    }
 
 
 
 
}

缘梦 CC
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
IO模型编程实例
05-09
4种IO模型编程实例： 阻塞IO 无阻塞IO 多路复用IO 异步IO
netty面试专题-答案-一起学习
04-17
1.BIO、NIO 和 AIO 的区别？ BIO：一个连接一个线程，客户端有连接请求时服务器端就需要启动一个线程进行处理。线 程开销大。 伪异步 IO：将请求连接放入线程池，一对多，但线程还是很宝贵的资源。 NIO：一个请求一个线程，但客户端发送的连接请求都会注册到多路复用器上，多路复用 器轮询到连接有 I/O 请求时才启动一个线程进行处理。 AIO：一个有效请求一个线程，客户端的 I/O 请求都是由 OS 先完成了再通知服务器应用去 启动线程进行处理， BIO 是面向流的，NIO 是面向缓冲区的；BIO 的各种流是阻塞的。而 NIO 是非阻塞的；BIO 的 Stream 是单向的，而 NIO 的 channel 是双向的。 NIO 的特点：事件驱动模型、单线程处理多任务、非阻塞 I/O，I/O 读写不再阻塞，而是返 回 0、基于 block 的传输比基于流的传输更高效、更高级的 IO 函数 zero-copy、IO 多路复用 大大提高了 Java 网络应用的可伸缩性和实用性。基于 Reactor 线程模型。 在 Reactor 模式中，事件分发器等待某个事件或者可应用或个操作的状态发
python 并发编程 多路复用IO模型详解
09-18
主要介绍了python 并发编程 多路复用IO模型详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
多路IO复用并发服务器模型 ppt 信息安全 产品开发实践 课件
11-15
多路IO复用并发服务器模型 ppt 信息安全 产品开发实践 课件
Linux编程--IO多路复用
xinqi_1的博客
06-17 1231
IO多路复用是指通过一种机制，使得单个进程可以监控多个文件描述符的可读、可写和异常等事件。常见的IO多路复用技术包括：select、poll、epoll等。在实际应用中，IO多路复用可以提高程序的运行效率和性能，减少系统开销，降低系统资源的使用率。它广泛应用于网络编程、服务器开发、操作系统等领域，可以帮助开发人员更好地处理大量的网络连接和数据请求。
C++ select模型详解（多路复用IO）
田螺姑娘的博客
11-25 2556
C++ select模型详解（多路复用IO） TIPS：以下内容纯属博主自主查阅资料并结合个人理解得出，各位读者仅做参考即可。 关于其它的IO模型可参考链接（阻塞I/O、非阻塞I/O、多路复用I/O、信号I/O、异步I/O）： 引言   在什么情况下需要使用select模型呢？阻塞I/O问题我们可以使用多线程处理或者将阻塞I/O改为非阻塞I/O，系统调用之后就返回结果，可是完成I/O（即获取数据），我们不得不使用polling（轮询），可每次轮询都是一次系统调用，这将导致一些情况下非阻塞I/O甚至不
Java原生网络编程 ---- IO多路复用
ZH的博客
05-14 1722
Java是在jdk1.4引入支持NIO的库。前面博客说过BIO通讯，这种模式下服务端一个线程只处理一个会话。当线程被阻塞在read() 或 write()时，不能够做其他的事情。线程在服务器属于比较昂贵的资源。BIO的方式会造成很大的资源浪费。NIO，被称为IO多路复用，中心思想既是对服务器的线程进行复用，从而提高服务器资源利用的效率。
网络编程-IO多路复用
CC的博客
10-02 715
网络编程-IO多路复用（select/poll/epoll）
网络编程学习日记-----多路复用
KLh
05-18 1161
一、IO模型 --- 多路复用。 1、什么是多路复用？ 就是先将需要监听的文件描述符/套接字加入到一个集合中，然后在规定时间/无限时间去监听这个集合，如果在规定时间/无限时间内有数据到达，则其余没有数据到达的文件描述符就会被自动剔除到集合之外，我们用户只需要观察集合中有哪些文件描述符/套接字剩下就可以了。 2、如何实现多路复用？ 1）定义一个集合。 数据类型： fd_set fd_set set; 2）删除、添加、清空、判断文件描述符在集合中？ --> man 2 select 就可以查询到
网络socket编程--多路复用
King_的博客
02-19 1606
一、五种网络I/O模型 1.什么是I/O IO在计算机中指Input/Output，也就是输入和输出。由于程序和运行时数据是在内存中驻留，由CPU这个超快的计算核心来执行，涉及到数据交换的地方，通常是磁盘、网络等，就需要IO接口。 比如你打开浏览器，访问新浪首页，浏览器这个程序就需要通过网络IO获取新浪的网页。浏览器首先会发送数据给新浪服务器，告诉它我想要首页的HTML，这个动作是往外发数据，叫Output，随后新浪服务器把网页发过来，这个动作是从外面接收数据，叫Input。所以，通常，程序完成IO操作会有
Linux网络编程—— IO多路复用
weixin_43412762的博客
03-03 1477
 I/O 多路复用 使得程序能 同时监听 多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用 的 系统调用主要有 select、poll 和 epoll。
42.Linux网络编程--IO多路复用（select poll epoll）
lzs940320的博客
05-10 1877
一. 预备知识 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），保证.
Java网络编程-IO多路复用(单线程)
怪盗基德
04-28 5941
1. 简介 IO多路复用(multiplexing)属于同步IO网络模型 是以Reactor模式实现 常见的IO多路复用应用有：select、poll、epoll 有关于select的应用方式，请参阅[C语言] 基于Linux的一对一Socket简易聊天程序实例 本篇文章采用Java的NIO框架来实现单线程的IO多路复用 2. React
IO多路复用详解
氷的博客
05-30 1367
在IO多路复用模型中，引入了一种新的系统调用，查询IO的就绪状态。在Linux系统中，对应的系统调用为select/poll/epoll系统调用。通过该系统调用，一个进程可以监视多个文件描述符，一旦某个描述符就绪（一般是内核缓冲区可读/可写），内核能够将就绪的状态返回给应用程序。随后，应用程序根据就绪的状态，进行相应的IO系统调用。在IO多路复用模型中通过select/poll/epoll系统调用，单个应用程序的线程，可以不断地轮询成百上千的socket连接，当某个或者某些socket网络连接有IO就绪的状
Linux网络编程：网络基础
weixin_73234157的博客
05-20 908
当我们形成计算机网络后，小明要给他的暗恋对象小红发一句“我喜欢你”，结果发给了小芳……，在计算机网络中会出现许许多多的主机，当我们进行网络通信时，我们要通过协议来找到指定的接收方。同理在单台主机中，数据从键盘中读入再转载到当前网卡也是需要协议的。简单来说：协议就是一种约定当计算机在读取数据时，发现数据中存在向网卡输送的标志（协议）时，就往网卡输送。当网卡读取到输送给小红，网卡就不会发送给小芳。
计算机网络
zengkui198513的博客
05-15 641
上面的每一个问题是每一层都必须面对的也都必须要解决的。每一层而且必须要覆盖上面的信息！
用docker命令行操作远程的Dockerd daemon服务
zhang197093的博客
05-15 696
本地安装Dockerd服务太耗本机磁盘空间了，共用已有的Dockerd服务能够节省一部分空间。
嵌入式学习
qq_46068832的博客
05-19 397
【代码】嵌入式学习。
计算机网络安全控制技术
最新发布
heikewhite的博客
05-25 228
防火墙技术是近年来维护网络安全最重要的手段，但是防火墙不是万能的，需要配合其他安全措施来协同。目前加密技术主要有两大类：对称加密和非对称加密。核心是识别网络者是否是属于系统的合法用户。入侵行为主要是指对系统资源的非授权使用。计算机病毒的数目和危害性都在飞速发展。控制不同的用户对信息资源的访问权限。漏洞检测和安全风险评估技术。6.网络安全漏洞扫描技术。
io多路复用模型的运行原理
03-24
IO多路复用模型的运行原理是，程序使用一个I/O多路复用函数，如select、poll、epoll等，同时监听多个文件描述符上的事件，当有一个或多个文件描述符上的事件需要进行处理时，程序会被唤醒，然后针对需要处理的文件...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值