网络编程之I_O Multiplexing总结(四)

理解Linux五种I/O模型、同步I/O与异步I/O、阻塞与非阻塞 五种IO模型 、五种I/O模型的比较 、同步I/O与异步I/O 阅读详情

1. 概念澄清

1.1

A socket is ready for reading if any of the following four conditions is true:

  • The read half of the connection is closed (i.e., a TCP connection that has received a FIN). A read operation on the socket will not block and will return 0 (i.e., EOF)

A socket is ready for writing if any of the following four conditions is true:

  • The write half of the connection is closed. A write operation on the socket will generate SIGPIPE (Section 5.12).

StackOverflow上关于这个问题给出了答案,其实一开始看到这个问题,难以理解的就是shutdown(xxxx,SHUT_RD),一端调用该函数代表其不再接收数据,但是如果假设active close的一端首先调用该函数,显然是无法理解的,因为一般都是发送数据方作为active close端,而作为passive close端调用该函数,又多此一举,在百科中说该函数调用为空操作不权威,这个问题先按照常见的一种情形处理:
  这里写图片描述

1.2

TCP的状态变化图回顾:
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

从理论上分析首先client处于FIN_WAITE_1,之后接收到server的ACK后,变化到FIN_WAITE_2,等待server的FIN;server此时接收到client的FIN后处于CLOSE_WAIT状态,之后其调用close向client发送FIN,自己进入LAST_ACK,等待client的ACK。
  腾讯的面经会有提问TIME_WAIT的作用,现在回顾如下:

  • To implement TCP’s full-duplex connection termination reliably
  • TIME_WAIT状态用来重复发送ACK,假设第一次FIN_WAIT_2回复的ACK丢失的话,该TIME_WAITE状态持续2MSL。
  • To allow old duplicate segments to expire in the network
  • 相同地址和端口号建立的连接不希望接收到lost duplicate,也就是上次连接的数据,则使用该状态让当前连接的数据全部过期。

2. Select server和Client的改进代码

2.1 Server

//6_ser.c
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>
#include <err.h>
#define INET_ADDRSTRLEN 16
#define LISTENQ 10
#define SERV_PORT 9877
#define MAXLINE 20
#define handle_error(msg) \
          do { perror(msg); exit(EXIT_FAILURE); } while (0)
void str_echo(int sockfd);
ssize_t writen(int fd, const void *vptr, size_t n);


int main(int argc, char **argv)
{
    int i, maxi, maxfd, listenfd, connfd, sockfd;
    int nready, client[FD_SETSIZE];
    char strcliaddr[INET_ADDRSTRLEN];
    ssize_t n;
    fd_set rset, allset;
    char buf[MAXLINE];
    socklen_t clilen;
    struct sockaddr_in cliaddr, servaddr;
    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
        handle_error("socket");
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);
    if(bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) == -1)
        handle_error("bind");
    if(listen(listenfd, LISTENQ) == -1)
        handle_error("listen");
    maxfd = listenfd; /* initialize */
    maxi = -1; /* index into client[] array */
    for (i = 0; i < FD_SETSIZE; i++)
        client[i] = -1; /* -1 indicates available entry */
    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);
    for ( ; ; ) {
        rset = allset; /* structure assignment */
        if((nready=select(maxfd+1, &rset, NULL, NULL, NULL)) == -1)
            handle_error("select");
        if (FD_ISSET(listenfd, &rset)) { /* new client connection */
            clilen = sizeof(cliaddr);
            if((connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen)) == -1 )
                handle_error("accept");
            for (i = 0; i < FD_SETSIZE; i++)
            if (client[i] < 0) {
                client[i] = connfd; /* save descriptor */
                break;
            }
            if (i == FD_SETSIZE)
                errx(1,"too many clients");
            if(inet_ntop(AF_INET,&cliaddr.sin_addr,strcliaddr,INET_ADDRSTRLEN) == NULL)
				handle_error("inet_pton");
		    printf("connected client number : %d, ipaddress:%s\n",i,strcliaddr);
            FD_SET(connfd, &allset); /* add new descriptor to set */
            if (connfd > maxfd)
                maxfd = connfd; /* for select */
            if (i > maxi)
                maxi = i; /* max index in client[] array */
            if (--nready <= 0)
                continue; /* no more readable descriptors */
        }
        for (i = 0; i <= maxi; i++) { /* check all clients for data */
            if ( (sockfd = client[i]) < 0)
                continue;
            if (FD_ISSET(sockfd, &rset)) {
                if ( (n = read(sockfd, buf, MAXLINE)) < 0)
                    handle_error("read");
                if(n == 0){
				    if(getpeername(sockfd,(struct sockaddr *) &cliaddr, &clilen)== -1)
						handle_error("getpeername");
				    if(inet_ntop(AF_INET,&cliaddr.sin_addr,strcliaddr,INET_ADDRSTRLEN) == NULL)
						handle_error("inet_pton");
				    printf("closed client number : %d, ipaddress:%s\n",i,strcliaddr);
                    if(close(sockfd) == -1)
                        handle_error("close");
				    if(i ==  maxi)
						maxi-=1;

                    FD_CLR(sockfd, &allset);
                    client[i] = -1;
                } else
                    if(writen(sockfd, buf, n) == -1)
                        handle_error("writen");
                if (--nready <= 0)
                    break; /* no more readable descriptors */
           }
        }
    }
}
void str_echo(int sockfd)
{
    ssize_t n;
    char buf[MAXLINE];
    again:
        while ( (n = read(sockfd, buf, MAXLINE)) > 0)
            if(writen(sockfd, buf, n) == -1)
                handle_error("writen");
        if (n < 0 && errno == EINTR)
            goto again;
        else if (n < 0)
            errx(1,"str_echo: read error");
}

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; /* and call write() again */
            else
                return (-1); /* error */
        }
        nleft -= nwritten;
        ptr += nwritten;
    }
    return (n);
}

2.2 Client

//6_cli.c
#include <sys/socket.h>
#include <sys/un.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <err.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>
#define SERV_PORT 9877
#define MAXLINE 20
#define handle_error(msg) \
          do { perror(msg); exit(EXIT_FAILURE); } while (0)
ssize_t writen(int fd, const void *vptr, size_t n);
void str_cli(FILE *fp, int sockfd);
int max(int,int);

int main(int argc, char **argv)
{
    int sockfd;
    struct sockaddr_in servaddr;

    if (argc != 2)
        errx(1,"usage: tcpcli <IPaddress>");

    if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
        handle_error("socket");
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    if(inet_pton(AF_INET, argv[1], &servaddr.sin_addr) == -1)
        handle_error("inet_pton");

    if(connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) == -1)
        handle_error("connect");
    str_cli(stdin, sockfd);
    exit(0);
}
int max(int a,int b)
{
	return a < b? b:a;
}
void str_cli(FILE *fp, int sockfd)
{
        int maxfdp1, stdineof;
        fd_set rset;
        char buf[MAXLINE];
        int n;
        stdineof = 0;
        FD_ZERO(&rset);
        for ( ; ; ) {
                if (stdineof == 0)
                FD_SET(fileno(fp), &rset);
                FD_SET(sockfd, &rset);
                maxfdp1 = max(fileno(fp), sockfd) + 1;
                if(select(maxfdp1, &rset, NULL, NULL, NULL) == -1)
                        handle_error("select");
                if (FD_ISSET(sockfd, &rset)) { /* socket is readable */
                        if ( (n = read(sockfd, buf, MAXLINE)) < 0)
                                handle_error("read");
                        if( n == 0){
                                if (stdineof == 1)
                                        return; /* normal termination */
                                else
                                        errx(1,"str_cli: server terminated prematurely");
                        }
                        if( write(fileno(stdout), buf, n) == -1 )
                                handle_error("write stdio");
                }
                if (FD_ISSET(fileno(fp), &rset)) { /* input is readable */
                        if ( (n = read(fileno(fp), buf, MAXLINE)) < 0)
                                handle_error("read");
                        if(n == 0){
                                stdineof = 1;
                                if(shutdown(sockfd, SHUT_WR)== -1)
                                        handle_error("shutdown");/* send FIN */
                                FD_CLR(fileno(fp), &rset);
                                continue;
                        }
                        if(writen(sockfd, buf, n) == -1)
                                handle_error("writen");
                }
        }
}
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; /* and call write() again */
            else
                return (-1); /* error */
        }
        nleft -= nwritten;
        ptr += nwritten;
    }
    return (n);
}

3. 结果验证

//server端
[root@localhost ~]# ./6_ser
connected client number : 0, ipaddress:127.0.0.1
connected client number : 1, ipaddress:192.168.182.130
closed client number : 0, ipaddress:127.0.0.1
closed client number : 1, ipaddress:192.168.182.130

//client0
[root@localhost ~]# ./6_cli 127.0.0.1
this is the first client.
this is the first client.
//CTRL+D
[root@localhost ~]#

//client1
[root@localhost ~]# ./6_cli 192.168.182.130
this is the second client.
this is the second client.
//CTRL+D
[root@localhost ~]#

以上两个client同时连接到server,但是该server是single loop,意味着对于client数据量比较大的时候,阻塞其他client接受server的服务。然后看看状态转化,以一个client为例:

//server继续等待,此时上面两个连接已经结束,9877为server的端口。
[root@localhost ~]# netstat -a
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State      
tcp        0      0 0.0.0.0:9877            0.0.0.0:*               LISTEN  
//笔者是同一台电脑多个终端,所以这里看到两个建立连接的socket,59750是clinet的端口
[root@localhost ~]# ./6_cli 192.168.182.130
//等待输入
[root@localhost ~]# ./6_ser
connected client number : 0, ipaddress:127.0.0.1
connected client number : 1, ipaddress:192.168.182.130
closed client number : 0, ipaddress:127.0.0.1
closed client number : 1, ipaddress:192.168.182.130
connected client number : 0, ipaddress:192.168.182.130 //上面新连接的client

//此时观察netstat
[root@localhost ~]# netstat -a | grep tcp
tcp        0      0 0.0.0.0:9877            0.0.0.0:*               LISTEN     
tcp        0      0 0.0.0.0:ssh             0.0.0.0:*               LISTEN     
tcp        0      0 localhost.localdom:9877 localhost.localdo:59750 ESTABLISHED
tcp        0      0 localhost.localdo:59750 localhost.localdom:9877 ESTABLISHED
//在client键入EOF,迅速查看结果,client的TCP处于TIME_WAIT状态,server端的socket已经关闭
[root@localhost ~]# netstat -a | grep tcp
tcp        0      0 0.0.0.0:9877            0.0.0.0:*               LISTEN     
tcp        0      0 localhost.localdo:59750 localhost.localdom:9877 TIME_WAIT  

4.总结

client和server都采用select处理,为了在server显示连接的client,及client结束时打印相应的信息,笔者用了inet_pton和getpeername,对于maxi的处理,笔者只是简单的让其减一。最后这两个代码本身的缺陷,在以前的章节有讨论过,在此不赘述。

【雕爷学编程】MicroPython手册之内置模块 uselect - 异步I/O multiplexing模块 然后,我们进入一个无限循环,等待事件发生。当等待时间到达时,我们可以在事件列表中检测到相应的事件,并执行相应的操作,如打印定时器事件发生的消息。MicroPython的内置模块uselect是一个用于异步I/O多路复用的模块,它实现了CPython模块的一个子集,但也有一些特殊的特点和限制。2、uselect模块还提供了一个Poll类,用于表示一个轮询对象,以及一个register、unregister、modify、poll和ipoll方法,用于注册、注销、修改、等待和迭代轮询对象中的事件。 阅读详情

相关推荐

SFR算法实现详解:从边缘检测到MTF计算的完整流程

本文详细解析了SFR算法从边缘检测到MTF计算的完整流程,包括边缘检测、ESF超采样、LSF差分等关键步骤。通过代码示例和实战经验,帮助开发者高效实现成像系统解析力评估,优化MTF测量精度。适用于摄像头模组调试、工业检测等场景。

Black的专栏 1010

I/O 多路复用(I/O Multiplexing)

I/O 多路复用(I/O Multiplexing)是指在单个线程中同时管理多个 I/O 操作的技术。它允许程序同时处理多个输入输出流而无需为每个流创建一个独立的线程。I/O 多路复用通常用于网络编程中,尤其是在需要高效处理大量连接的情况下(例如 Web 服务器或数据库服务器)。I/O 多路复用的核心思想是通过一个线程同时监听多个 I/O 事件,并根据事件的就绪情况来执行相应的操作。常见的 I/O 多路复用机制包括selectpoll和epoll。

宋发元 1172

comsol 多物理场仿真流程-以开关柜为例

1、主要方法 在SolidWorks中对于开关柜的内部与外部结构进行建模,生成能够导入软件计算的3D模型。将SolidWorks中的模型导入comsol软件中,设置参数进行多物理场耦合仿真。 1、具体步骤 删除高压开关柜中对其内部电磁环境无较大影响的结构,如低压测量柜、断路器内部结构等。 导入模型:将厂家提供的3D模型转化为solidworks结构模型。 修复模型:修复已转化模型中转化错误的部分、修复已转化模型中非实体部分、修复已转化模型中重叠实体部分 化简模型:去除过于...

健忘16的博客 7022

I/O Multiplexing & select

什么是I/O Multiplexing?  I / O多路转接(I/O multiplexing),其基本思想是:先构造一张有关描述符的表,然后调用一个函数,它要到这些描述符中的一个已准备好进行 I / O时才返回。 在返回时,它告诉进程哪一个描述符已准备好可以进行 I / O。 IO multiplexing就是我们说的select,poll,epoll,有些地方也称这种IO方式为

shun_fzll的专栏 588

点云中的Minkowski卷积

一、MinkowskiEngine简介 第一次见到MinkowskiEngine,应该是在两个月之前了,当时也没有去留意这个库。最近读了一些点云的论文,发现还是有不少论文的源码是基于MinkowskiEngine的,包括PointContrast(ECCV 2020),DGR(Deep Global Registration, CVPR 2020),Learning Multiview 3D Point Cloud Registration(CVPR 2020)和FCGF(Fully Convolution

zhulf0804的博客 7908

新手必看:如何用T265和ROS实现无人机室内精准定位(附PX4参数配置)

本文详细介绍了如何使用Intel Realsense T265和ROS实现无人机室内精准定位,包括硬件准备、ROS数据流架构设计、PX4参数配置及系统验证。特别针对视觉SLAM技术在室内环境中的应用,提供了从零搭建到进阶优化的全流程解析,适合无人机开发新手快速上手。

weixin_30642561的博客 407

UNIX网络编程1 理解同步、阻塞、非阻塞、异步网络I/O

本文侧重的是网络I/O,如blocking、non-blocking、I/O multiplexing(event driven I/O)、signal-driven(不常用)、 asynchronous这几种UNIX网络编程中提到的模型。 wiki中的Asynchronous I/O认为,asynchronous I/O和non-blocking I/O是一个意思,都是指一种I/O处理形式:在

hustsselbj的专栏 1139

PayPal支付集成完全指南:开源库实践

本文介绍了如何从零开始集成PayPal支付功能。首先概述了PayPal提供的多语言SDK和开源库,包括PHP、Python、Node.js等版本。然后详细说明了准备工作,包括注册开发者账号、获取API凭证和使用沙盒环境测试。文章以Node.js为例,演示了安装SDK、基础配置和实现支付流程的完整代码,包括创建订单和捕获支付两个核心功能。最后提及了订阅支付等高级功能,为开发者提供了完整的支付集成方案。通过清晰的代码示例和步骤说明,帮助开发者快速实现PayPal支付功能集成。

2501_93501927的博客 1262

I/O模型与I/O复用

阅读目录 1 基础知识回顾 2 I/O模式 3 事件驱动编程模型 4 select/poll/epoll的区别及其Python示例   网络编程里常听到阻塞IO、非阻塞IO、同步IO、异步IO等概念,总听别人装13不如自己下来钻研一下。不过,搞清楚这些概念之前,还得先回顾一些基础的概念。 回到顶部 1 基础知识回顾 注意:咱们下面说的都是Linux环境下,跟Windows不一样哈~~...

zhou_xing_23的博客 326

基于YOLOv8的视频监控违规停车智能识别系统与应用研究

通过这个毕设,你已经从数据准备、模型训练到界面开发,完整走了一遍深度学习项目的流程。把多个停车场的监控数据整合起来,做一个区域级的停车管理平台;加入车牌识别功能,直接定位到违规车辆的车主;试试把YOLO模型再优化一下,让它在手机端也能运行,实现移动巡检。相信我,按照这个教程一步步做,你的毕设不仅能顺利完成,还能做出亮点,让答辩老师眼前一亮。要是过程中遇到什么问题,随时可以再琢磨琢磨,或者找我聊聊,咱们一起把这个毕设做成精品。

LXY_LOVE36的博客 119

RK3399快速上手 | 01- 开发环境搭建(固件烧写、编译工具链安装、kernel编译)

一、编译工具链 编译工具链使用gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu。 下载地址: https://releases.linaro.org/components/toolchain/binaries/6.3-2017.05/arm-linux-gnueabihf/ wget https://releases.linaro.org/components/toolchain/binaries/6.3-2017.05/arm-linux-gnueabi

Mculover666的博客(嵌入式) 8837

selector多路复用_I/O多路复用技术(multiplexing)是什么?

前言当我们要编写一个echo服务器程序的时候,需要对用户从标准输入键入的交互命令做出响应。在这种情况下,服务器必须响应两个相互独立的I/O事件:1)网络客户端发起网络连接请求,2)用户在键盘上键入命令行。我们先等待哪个事件呢?没有哪个选择是理想的。如果在acceptor中等待一个连接请求,我们就不能响应输入的命令。类似地,如果在read中等待一个输入命令,我们就不能响应任何连接请求。针对这种困境的...

weixin_39618574的博客 300

RT-DETR算法优化改进:Backbone改进 | HGBlock完美结合PPHGNetV2 GhostConv

GhostConv助力RT-DETR ,HGBlock与PPHGNetV2 GhostConv完美结合

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 2917

IO multiplexing 与 非阻塞网络编程

来源:http://www.cnblogs.com/zhuyp1015/p/3560095.html   使用I/O multipexing(网络-多路复用(即多路信号共用一个网络信道,由此产生网络大I/O)) 的网络编程中,一般需要采用非阻塞网络编程的风格,防止服务端在处理高连接量大时候阻塞在某个文件描述符上面,比如某个socket 有大量的数据需要写,但是内核发送缓冲区已经填满,无法在...

weixin_34117522的博客 286

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

计算机 I/O 模型完全指南

本文系统梳理了计算机I/O模型的分类与特点。主要内容包括: I/O过程解析:分为数据就绪等待和数据拷贝两个阶段,不同模型在这两个阶段的处理方式不同。 关键概念区分: 阻塞/非阻塞:关注调用时进程是否挂起 同步/异步:关注数据拷贝由谁完成和通知方式 五种经典I/O模型详解: 阻塞I/O:简单但效率低 非阻塞I/O:需要轮询检查 I/O多路复用:select/poll/epoll实现单线程管理多连接 信号驱动I/O:通过信号通知 异步I/O:内核完成所有操作后通知 对比总结:从同步/异步、阻塞/非阻塞维度分析各

zx020986的博客 393

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

IO模型及select、poll、epoll和kqueue的区别

先说下本文框架,先是问题引出,然后概括两个机制的区别和联系,最后介绍每个接口的用法 一、问题引出 联系区别 问题的引出,当需要读两个以上的I/O的时候,如果使用阻塞式的I/O,那么可能长时间的阻塞在一个描述符上面,另外的描述符虽然有数据但是不能读出来,这样实时性不能满足要求,大概的解决方案有以下几种: 1.使用多进程或者多线程,但是这种方法会造成程序的复杂,而且对与进程与线程的创

单向街的夏天 6246

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Linux 网络编程 ——2025年度深度总结

Linux网络编程2025年度深度总结 本文系统梳理了Linux网络编程的核心原理与实践经验。首先从通信基础入手,解析了协议分层设计(TCP/IP五层模型)和地址体系(MAC/IP/端口)的协同机制。其次对比了UDP与TCP两种传输哲学:UDP以无连接、高效著称,适合实时应用;TCP通过复杂机制确保可靠传输。在应用层方面,探讨了自定义协议设计(二进制/JSON序列化)与HTTP/HTTPS实践。最后深入I/O多路复用演进(从select到epoll)和内核视角(socket/sk_buff)。全文立足202

htw250056的博客 1549

C#网络编程(六)----Socket编程模型

Socket(套接字)是计算机网络中的一套编程接口,是网络编程的核心,它将复杂的网络协议封装为简单的API,是应用层(HTTP)与传输层(TCP)之间的桥梁。应用程序通过调用Socket API,比如connect、send、recv,无需处理IP包封装,路由选择等复杂网络操作,屏蔽底层细节将网络通信简化为建立连接-数据接收-数据发送-连接断开,降低了开发复杂度。

weixin_33741534的博客 95

浅谈Unix I/O模型

关于I/O模型的文章比较多,参考多篇后理解上仍然不太满意,终需自己整理一次,也是编写高吞吐量高性能网络接口模块的基础。这里所说的主要针对网络I/O,近几年面对越来越大的用户请求量,如何优化这些步骤直接影响接口用户体验。 一、前言 I/O模型有几个名词的解释 (比较容易混淆): 阻塞与非阻塞:区别在于调用函数时,是否立即返回还是让线程等待。阻塞模型需要等待操作完成,而非阻塞模型则是立...

weixin_33726313的博客 169

I/O子系统:select,poll,epoll,kqueue, iocp(Windows)及各种I/O复用机制 模式Reactor Proactor

I/O子系统:select,poll,epoll,kqueue, iocp(Windows)及各种I/O复用机制 模式Reactor Proactor 分类: 1.1.1.20 I/O子系统 1.1.1.11 通信框架 1.1.1.10 网络与通信 1.1.1.1 操作系统OS2014-01-12 17:04 119人阅读 评论(0) 收藏 举报 目录(?)[+]

junecauzhang的专栏 1551

linux i/o multiplexing

socket也是io的一种,阻塞的socket操作包括: 输入:recv(), recvfrom(),缓冲区为空时阻塞 输出:send(), sendto(),缓冲区为空时阻塞 接受:accept(),无连接时阻塞 连接:connect(),无响应时阻塞,对TCP连接而言会阻塞一个服务器往返时间 几种io复用的解决方案比较: select poll epo...

weixin_30611509的博客 101

I/O多路复用技术

       在I/O编程过程中,当需要同时处理多个客户端接入请求时,可以利用多线程或者I/O多路复用技术进行处理。I/O多路复用技术通过把多个I/O的阻塞复用到同一个select的阻塞上,从而使得系统在单线程的情况下可以同时处理多个客户端请求。与传统的多线程/多进程模型相比,I/O多路复用的最大优势是系统开销小,系统不需要创建新的额外进程或者线程,也不需要维护这些进程和线程的运行,降低了系统的维...

BENZBMWAODI的博客 490

I/O复用 select模型使用实例

在这两篇文章基础上 http://blog.youkuaiyun.com/qq_26437925/article/details/51898120http://blog.youkuaiyun.com/qq_26437925/article/details/51900405参考《unix网络编程:卷1》我们看到TCP同时两个输入:标准输入 和 TCP套接字。 当客户端阻塞于标准输入时(即fget调用,一直等待用户输入数据

master-dragon的专栏 1394
上一篇: 进程IPC之论证充分的探讨Key和Identifier的关系(五)
下一篇: 从零快速解析之Tinyhttp源码解析(一)
LoveStackover
博客等级 码龄9年 14粉丝 57原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值