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

原创 已于 2024-01-29 10:17:59 修改 · 209 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络 #redis #数据库

于 2018-03-15 16:35:56 首次发布
本文通过具体示例介绍如何使用select机制管理TCP连接，并展示了客户端和服务端的实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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的处理，笔者只是简单的让其减一。最后这两个代码本身的缺陷，在以前的章节有讨论过，在此不赘述。

C 语言网络编程 — Socket I/O 性能优化手段
烟云的计算
05-04 4934
目录 文章目录目录基本概念同步与异步阻塞与非阻塞五种 IO 模型阻塞 IO非阻塞 IO同步 IO（信号驱动）异步 IOIO 多路复用selectpollepoll 基本概念 同步与异步 同步是指一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成。 异步是指不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了...
高效I/O处理：模型与多路复用的探讨
热门推荐
张彦峰的博客
06-15 10万+
本文介绍了 I/O 操作的五种主要模型：阻塞 I/O、非阻塞 I/O、同步 I/O、异步 I/O 和信号驱动 I/O，并分析了它们在现代计算机系统中的应用。重点讨论了多路复用技术（如 select、poll 和 epoll）在高并发场景中的重要性及其如何提升 I/O 操作的效率。通过对这些模型和技术的深入理解，开发者能够选择合适的 I/O 方案，以优化应用性能，提升用户体验。
I/O详解与五种网络I/O模型
dearQiHao的博客
02-25 2183
五种网络I/O模型的介绍
简要概述网络I/O与并发
田螺姑娘的博客
11-25 3481
简要概述网络I/O与并发 以下内容可能存在错误，由博主自主查阅资料所得，仅作参考。   计算机的基本组成其实很简单，处理器，存储器加上输入输出设备就构成了计算机。大至超级计算机，小到手机发等都是一样的模型组成。计算的本质就是从输入设备读取数据处理后输出。可以理解计算机做的事就是IO和计算。   在网络发明之前，计算机从存储设备中读取数据，进程通过内存通道进行通信。互联网诞生之后，越来越多计算机通过互联网连接，将数据传输到世界各地。计算机之间可以通信，本质上也是计算机进程之间互相通信。为了方便不同终端进行
I/O 多路复用（I/O Multiplexing）
宋发元
03-22 714
I/O 多路复用（I/O Multiplexing）是指在单个线程中同时管理多个 I/O 操作的技术。它允许程序同时处理多个输入输出流而无需为每个流创建一个独立的线程。I/O 多路复用通常用于网络编程中，尤其是在需要高效处理大量连接的情况下（例如 Web 服务器或数据库服务器）。I/O 多路复用的核心思想是通过一个线程同时监听多个 I/O 事件，并根据事件的就绪情况来执行相应的操作。常见的 I/O 多路复用机制包括selectpoll和epoll。
理解网络I/O
敦煌的驼铃_Blog
06-18 402
网络I/O模型 1,概念： I/O,就是input/output,也就是输入输出。 比如对一个文件，一个socket 的写入/读取就是一个i/o 磁盘i/o，操作文件的i/o，比如给文件写入数据，读取数据 网络i/o，对一个socket连接的i/o，比如一个tcp连接，客户端和服务端的写入，读取 注意：本文的I/O模型只讨论网络I/O 2,五大I/O模型 1总览 对于网络I/O操作，抽象了五大I/O模型,分别是 1,阻塞I/O 2,非阻塞I/O 3,I/O
Linux网络编程之I/O复用
Aaron的专栏
04-24 2442
Linux编程之IO多路复用(I/O Multiplexing) 程序设计过程中有时候会对多个输入进行操作，例如标准输入或者多个socket。那么如果在对某个进行处理的时候阻塞住的话，另外的输入进来的话会得不到及时的处理。（比如客户端程序调用fgets／cin的时候会阻塞在标准输入的地方，此时如果有监听的socket请求连接的话是得不到及时处理的）。 对于这种情况就需要当内核发现我们指定的IO
【编程基础知识】网络I/O模型详解：从阻塞到异步
Dylaniou的博客
09-24 1450
每种I/O模型都有其适用场景和优缺点。选择合适的I/O模型可以显著提高网络应用程序的性能和可扩展性。随着现代操作系统和编程语言的发展，开发者可以选择更多高效的方式来处理网络I/O。
【Linux之·网络编程·I/O复用·select】
m0_66203017的博客
05-11 888
Linux下进行网络编程时会有同步/异步，阻塞和非阻塞四种调用方式同步和异步的概念描述的是用户线程与内核的交互方式：同步是指用户线程发起IO请求后需要等待或者轮询内核IO操作完成后才能继续执行；异步是指用户线程发起IO请求后仍继续执行，当内核IO操作完成后通知用户线程，或是调用用户线程注册的回调函数。阻塞和非阻塞的概念描述的是用户线程调用内核IO操作的方式：阻塞是指IO操作在没有接受完数据或者是没有得到结果前不会返回，需要彻底完成后才能返回到用户空间；
高效网络编程术：展讯平台I_O模型与多线程的深入理解
本文首先对高效网络编程技术进行了全面概述，接着深入分析了展讯平台的I/O模型及其在平台架构中的必要性和实践应用。随后，文章详细探讨了多线程编程的概念、原理和编程模型，并提供了展讯平台在多线程编程接口和...
refhgrces.rar_网络编程_C/C++_
08-09
5. **多路复用（Multiplexing）**：为了处理多个并发连接，可以使用`select()`、`poll()`或`epoll`等I/O多路复用技术，它们可以监控多个套接字的就绪状态。 6. **错误处理（Error Handling）**：网络编程中必须处理...
秋招笔记-8.6
lastXuanGod的博客
08-06 1349
昨天开组会投文章以及玩苏丹的游戏去了，今天得知不久后有面试，所以我们需要快速地过一下基本的八股和项目。
工业数采引擎-通信链路SOCKET
arno1988的专栏
08-05 771
工业数采引擎-通信链路SOCKET
网络原理——初识
suger__salt的博客
08-06 593
网络互联网络互联指将多台计算机连接在一起，完成数据共享数据共享本质是⽹络数据传输，即计算机之间通过⽹络来传输数据，也称为⽹络通信。根据⽹络互连的规模不同，可以划分为和。局域网通过一个交换机时连接的电脑能够互联广域网游戏兴起了之后，出现了网游，这时就出现了广域网光宇网：把一大堆局域网进行相连，组成了更大的“局域网”由路由器连通，不断套娃。
【笔记】ROS1｜5 ARP攻击Turtlebot3汉堡Burger并解析移动报文【旧文转载】
shandianchengzi的博客
08-04 1078
本文介绍了如何使用ARP攻击技术干扰Turtlebot3汉堡机器人的ROS通信。作者首先讲解了ARP协议的基本原理和攻击依据，然后通过实验演示了如何利用arpspoof工具实施ARP欺骗攻击，包括干扰普通主机上网和小车与控制机的通信。文章提供了详细的实验步骤和思考题，并建议读者在虚拟机环境下进行实践。实验结果显示，通过持续发送虚假ARP响应包可以成功劫持网络通信，开启IP转发后虽能恢复但会降低网速。最后作者还演示了如何解析被攻击机器人的移动控制报文。
网络相关面试题总结
m0_74186706的博客
08-07 751
多字节数据在内存中的存储顺序，仅在异构计算机通信或跨网络传输时需关注。
NAT转化和VRRP配置
不会写代码的胖子
08-06 205
VRRP（Virtual Router Redundancy Protocol）是一种网络协议，用于在多个路由器之间提供网关冗余，确保当主网关故障时能够自动切换到备份网关，从而提高网络可靠性。在router1和router2查看主备份信息。在router1配置VRRP。在router2配置vrrp。
网络muduo库的实现（1）
IKUN2333的博客
08-04 984
网络库实现的核心目标muduo 网络库成功的原因将解决的问题控制在一个范围内，不追求大而全。
WebSocket 在多线程环境下处理 Session并发
最新发布
TOOZOOY的博客
08-07 436
WebSocket 在多线程环境下处理 Session并发时，常见问题包括状态冲突（如 IllegalStateException）、消息乱序、连接超时等。以下是综合各技术方案的解决方案，分为单机多线程和分布式集群两类场景：
Windows下的7种Winsocket I/O编程模型详解
Winsock提供了多种I/O（输入/输出）编程模型来满足不同类型的网络应用需求。这里将介绍7种常用的Winsock I/O编程模型，并提供相应的知识点。 ### 1. 阻塞式I/O模型（Blocking I/O Model） 在阻塞式模型中，一个I/O...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值