网络编程---IO复用方法

已于 2023-10-22 13:52:25 修改
阅读量54 收藏
点赞数 1
分类专栏： 网络编程 文章标签： c++
于 2023-09-21 22:19:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maderfaker/article/details/133150525
版权

select

函数是一个在多路复用I/O中经常使用的系统调用，它允许你监视多个文件描述符（通常是套接字）的状态，以确定哪些文件描述符可以进行读取、写入或者已经发生了异常等情况。

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

//nfds：被监视的文件描述符的数量，通常设置为最大文件描述符加 1。

//readfds：指向一个 fd_set 结构的指针，用于监视可读事件（数据已经准备好读取的套接字）。

//writefds：指向一个 fd_set 结构的指针，用于监视可写事件（数据可以写入的套接字）。

//exceptfds：指向一个 fd_set 结构的指针，用于监视异常事件。

//timeout：设置 select 调用的超时时间，它是一个 struct timeval 结构，可以设置为 NULL 表示无限等待，也可以设置为一个时间间隔，使 select 在指定的时间内超时返回。

工作方式

select 函数的工作方式如下：

①当调用 select 时，它会检查被监视的文件描述符集合（readfds、writefds 和 exceptfds）以查看哪些文件描述符已经准备好了。如果有任何文件描述符处于就绪状态，select 返回；否则它会等待，直到有文件描述符变为就绪状态或者超时。

②一旦 select 返回，我们可以遍历文件描述符集合，检查每个文件描述符的状态以确定它们的就绪状态。

③通常，我们会使用 FD_ISSET 宏来检查文件描述符是否在集合中。如果在集合中，表示相应的操作可以执行（读、写或异常）。

fd_set结构体

fd_set 是一个用于表示文件描述符集合的数据结构，它通常用于 select 函数中，用来指定需要监视的文件描述符。

操作和用法

①初始化 fd_set：在使用 fd_set 之前，通常需要使用 FD_ZERO 来将其初始化为空集合，表示没有任何文件描述符。

fd_set readfds;
FD_ZERO(&readfds);

②添加文件描述符：当要监视一个文件描述符，可以使用 FD_SET 将其添加到集合中。

int sockfd = ...;  // 假设有一个套接字
FD_SET(sockfd, &readfds);

③检查文件描述符状态：可以使用 FD_ISSET 宏来检查文件描述符是否在集合中，以确定其状态。通常，这是在 select 返回后用于检查就绪状态的操作。

if (FD_ISSET(sockfd, &readfds)) 
{
    // sockfd 已经准备好进行读取操作
}

④从集合中移除文件描述符：如果你不再需要监视某个文件描述符，可以使用 FD_CLR 将其从集合中移除。

FD_CLR(sockfd, &readfds);

使用fd_set的注意事项

①fd_set 是一个有限大小的数据结构，通常大小由操作系统定义。因此，它不能包含所有可能的文件描述符，特别是在高并发的网络应用中可能会受到限制。

②在不同的操作系统上， fd_set 的大小可能会有所不同。你可以使用 FD_SETSIZE 宏来获取 fd_set 的大小限制。

③当使用 select 函数时，它会修改 fd_set，将其中不符合就绪条件的文件描述符从集合中移除，因此在每次调用 select 之前，通常需要重新初始化 fd_set。

④fd_set 通常是一个全局变量，因为它需要在 select 调用之前和之后都可见。

select实例

接下来写一个基于非阻塞 I/O 多路复用的简单服务器程序。它可以处理多个客户端连接，同时监听客户端发来的数据，然后回复 "ok"。

服务器端

#include<iostream>
#include<unistd.h>
#include<cstring>
#include<sys/socket.h>
#include<sys/select.h>
#include <arpa/inet.h>

#define MAXFD 10  //定义了最大文件描述符数量，即服务器能够处理的最大连接数。

using namespace std;

int socket_init()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    if (sockfd == -1)
    {
        return -1;
    }

    struct sockaddr_in saddr;
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET;//地址族
    saddr.sin_port = htons(6000);//端口号
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");//地址

    int res = bind(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));

    if (res == -1)
    {
        cout << "bind error" << endl;
        return -1;
    }

    res = listen(sockfd, 5);

    if (res == -1)
    {
        return -1;
    }

    return sockfd;
}

//初始化文件描述符数组，将所有元素设为 -1
void fds_init(int fds[])
{
    for (int i = 0; i < MAXFD; i++)
    {
        fds[i] = -1;
    }
}

//向文件描述符数组中添加文件描述符
void fds_add(int fds[], int fd)
{
    for (int i = 0; i < MAXFD; i++)
    {
        if (fds[i] == -1)
        {
            fds[i] = fd;
            break;
        }
    }
}

//从文件描述符数组中删除文件描述符
void fds_del(int fds[], int fd)
{
    for (int i = 0; i < MAXFD; i++)
    {
        if (fds[i] == fd)
        {
            fds[i] = -1;
            break;
        }
    }
}

//接收客户端数据，如果客户端关闭连接，则从文件描述符数组中删除该套接字
void accept_client(int sockfd, int fds[])
{
    int c = accept(sockfd, NULL, NULL);
    if (c < 0)
    {
        return;
    }

    cout << "c= " << c << endl;

    fds_add(fds, c);
}

void recv_data(int c, int fds[])
{
    char buff[128] = { 0 };
    int n = recv(c, buff, 127, 0);
    if (n <= 0)
    {
        fds_del(fds, c);
        close(c);
        cout << "client close" << endl;
        return;
    }
    cout << "buff " << c << "=" << buff << endl;
    send(c, "ok", 2, 0);
}

int main()
{
    // 创建套接字
    int sockfd = socket_init();
    //创建文件描述符集合
    fd_set fdset;
    //初始化文件描述符数组
    int fds[MAXFD];
    fds_init(fds);
    //添加套接字到数组中
    fds_add(fds, sockfd);

    while (1)
    {
        // 清空文件描述符集合并找到最大的文件描述符
        FD_ZERO(&fdset);
        
        //确定监听范围，即确定有几个待处理文件描述符
        int maxfd = -1;
        for (int i = 0; i < MAXFD; i++)
        {
            if (fds[i] == -1)// 说明此位置没有文件描述符
            {
                continue;
            }
            //将文件描述符添加到集合中
            FD_SET(fds[i], &fdset);

            if (maxfd < fds[i])
            {
                maxfd = fds[i];
            }
        }

        struct timeval tv = { 5, 0 };//设定超时时间为5秒
        
        int n = select(maxfd + 1, &fdset, NULL, NULL, &tv);
        if (n == -1)
        {
            cout << "select error" << endl;
        }
        else if (n == 0)
        {
            cout << "time out" << endl;
        }
        else
        {
            for (int i = 0; i < MAXFD; i++)
            {
                if (fds[i] == -1)
                {
                    continue;
                }
                //检查文件描述符并确定其状态
                if (FD_ISSET(fds[i], &fdset))
                {
                    if (fds[i] == sockfd) // 表明有新连接请求
                    {
                        accept_client(sockfd, fds);
                    }
                    else//表明是已连接的客户端发送数据
                    {
                        recv_data(fds[i], fds);
                    }
                }
            }
        }
    }
}

客户端

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

int main() 
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) 
    {
        perror("Socket creation failed");
        exit(1);
    }

    struct sockaddr_in saddr;
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(6000);
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    int res = connect(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));
    if (res == -1) 
    {
        perror("Connect error");
        exit(1);
    }

    while (1) 
    {
        char buff[128] = {0};
        printf("Input (type 'end' to exit):\n");
        fgets(buff, 128, stdin);
        if (strcmp(buff, "end\n") == 0) 
        {
            break;
        }
        send(sockfd, buff, strlen(buff) - 1, 0);
        memset(buff, 0, 128);
        recv(sockfd, buff, 127, 0);
        printf("Received: %s\n", buff);
    }

    close(sockfd);
    exit(0);
}

运行结果：

poll

poll() 函数是一个用于进行多路复用的系统调用，它与 select() 类似.

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

//fds: 是一个指向 pollfd 结构体数组的指针，每个结构体描述一个待监视的文件描述符以及监视的事件类型。

//nfds: 是 fds 数组的大小，即待监视的文件描述符的数量。

//timeout: 是超时时间，以毫秒为单位。如果设置为负数，poll() 会一直阻塞直到有事件发生。如果设置为0，poll() 会立即返回。如果设置为正数，poll() 会等待指定时间后返回，不管是否有事件发生。

pollfd 结构体

struct pollfd 
{
    int fd;         // 文件描述符
    short events;   // 待监视的事件类型
    short revents;  // 实际发生的事件类型（由内核填充）
};

//events: 要监视的事件类型，可以是以下之一或它们的组合：

POLLIN文件描述符上有可读数据。
POLLOUT文件描述符上可以写入数据。
POLLPR有紧急数据可读（如带外数据）
POLLERR发生错误
POLLHUP发生挂起事件
POLLNVAL文件描述符不是一个有效的打开文件

返回值：

大于0：表示有事件发生，返回值为就绪文件描述符的数量。

等于0：表示超时，没有文件描述符处于就绪状态。

小于0：表示出现错误

poll实例

服务器端

#include<iostream>
#include<unistd.h>
#include<cstring>
#include<sys/socket.h>
#include<sys/select.h>
#include <arpa/inet.h>
#include<poll.h>

#define MAXFD 10

using namespace std;

int socket_init()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    if (sockfd == -1)
    {
        return -1;
    }

    struct sockaddr_in saddr;
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET;//地址族
    saddr.sin_port = htons(6000);//端口号
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");//地址

    int res = bind(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));

    if (res == -1)
    {
        cout << "bind error" << endl;
        return -1;
    }

    res = listen(sockfd, 5);

    if (res == -1)
    {
        return -1;
    }

    return sockfd;
}

void fds_init(struct pollfd fds[])
{
    for (int i = 0; i < MAXFD;i++)
    {
        fds[i].fd = -1;
        fds[i].events = 0;
        fds[i].revents = 0;
    }
}

void fds_add(struct pollfd fds[],int fd)
{
    for (int i = 0; i < MAXFD;i++)
    {
        if(fds[i].fd==-1)
        {
            fds[i].fd = fd;
            fds[i].events = POLLIN;//r
            fds[i].revents = 0;
            break;
        }
    }
}

void fds_del(struct pollfd fds[],int fd)
{
    for (int i = 0; i < MAXFD;i++)
    {
        if(fds[i].fd==fd)
        {
            fds[i].fd = -1;
            fds[i].events = 0;
            fds[i].revents = 0;
            break;
        }
    }
}

void accept_client(int sockfd,struct pollfd fds[])
{
    int c = accept(sockfd, NULL, NULL);
    if(c<0)
    {
        return;
    }
    cout << "accept c =" << c << endl;

    fds_add(fds, c);
}

void recv_data(int c,struct pollfd fds[])
{
    char buff[128] = {0};
    int n = recv(c, buff, 127, 0);
    if(n<=0)
    {
        fds_del(fds, c);
        close(c);
        cout << "client close" << endl;
        return;
    }
    cout << "recv buff =" << buff << endl;
    send(c, "ok", 2, 0);
}

int main()
{
    int sockfd = socket_init();
    if(sockfd==-1)
    {
        exit(1);
    }

    struct pollfd fds[MAXFD];
    fds_init(fds);
    fds_add(fds, sockfd);

    while(1)
    {
        int n = poll(fds, MAXFD, 5000);//可嫩会阻塞在这
        if(n==-1)
        {
            cout << "poll error" << endl;
        }

        else if(n==0)
        {
            cout << "time out" << endl;
        }

        else
        {
            for (int i = 0; i < MAXFD;i++)
            {
                if(fds[i].fd==-1)
                {
                    continue;
                }
                if(fds[i].revents&POLLIN)
                {
                    if(fds[i].fd==sockfd)//新客户
                    {
                        accept_client(sockfd, fds);
                    }
                    else//老客户
                    {
                        recv_data(fds[i].fd, fds);
                    }
                }
            }
        }
    }
}

客户端

与select实例中的相同

epoll

"epoll" 是 Linux 系统上用于高效 I/O 多路复用的一组系统调用和相关数据结构。它相比于传统的 select 和 poll 等方式，在处理大量连接时更加高效。

epoll 支持多种事件类型，其中常见的包括：

EPOLLIN表示文件描述符上有数据可读
EPOLLOUT表示文件描述符上可以写入数据
EPOLLET使用边缘触发模式（Edge Triggered），只通知一次事件
EPOLLRDHUP对端关闭连接或者半关闭
EPOLLERR发生错误
EPOLLHUP发生挂起事件

epoll_creat

int epoll_create(int size);//创建一个新的 epoll 实例的系统调用

//size:表示 epoll 实例可以管理的文件描述符的数量

工作方式

①调用 epoll_create 创建一个 epoll 实例。

②使用 epoll_ctl 添加要监视的文件描述符和事件类型，比如 EPOLLIN（读事件）或 EPOLLOUT（写事件）。

③调用 epoll_wait 等待事件的发生。这个函数会一直阻塞，直到有文件描述符上的事件发生或者达到设置的超时时间。

epoll_ctl

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

//epfd：epoll 实例的文件描述符，是之前由 epoll_create 创建的。 //op：表示要执行的操作，可以是以下值之一：

EPOLL_CTL_ADD添加一个文件描述符到 epoll 实例中，使得 epoll 可以监视它
EPOLL_CTL_MOD修改一个文件描述符在 epoll 实例中的事件监听
EPOLL_CTL_DEL从 epoll 实例中删除一个文件描述符，不再监听它

//fd：要操作的文件描述符，可以是套接字、文件等。

//event：一个 struct epoll_event 结构，描述了要监听的事件类型，可以包括读事件、写事件等。

工作方式

①创建一个 struct epoll_event 结构，设置需要监听的事件类型，例如 EPOLLIN 表示读事件、EPOLLOUT 表示写事件等。 ②调用 epoll_ctl 函数来添加、修改或删除文件描述符的事件监听。通过设置 op 参数来指定具体的操作。 ③如果添加或修改操作成功，epoll_ctl 函数返回 0，否则返回 -1，并可以使用 errno 获取错误信息

epoll_wait

是 epoll 系列系统调用之一，用于等待文件描述符上的事件发生，并将就绪的文件描述符返回给调用者。

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

//epfd：epoll 实例的文件描述符，由 epoll_create 创建。 //events：用于存储就绪事件的数组，每个元素都是一个 struct epoll_event 结构体。 //maxevents：events 数组的大小，表示最多可以存储多少个就绪事件。 //timeout：超时时间，单位是毫秒，指定等待多长时间。传递 -1 表示一直等待，传递 0 表示立即返回，传递正整数表示等待指定的毫秒数。

工作方式

①创建一个 epoll 实例，通过 epoll_create1 或者 epoll_create 函数，得到一个 epoll 文件描述符 epfd，该描述符代表了一个 epoll 实例。

②使用 epoll_ctl 函数将需要监听的文件描述符添加到 epoll 实例中，同时指定关心的事件类型（如读、写、异常等）以及相关的事件数据。

③调用 epoll_wait 函数等待事件的发生。epoll_wait 会一直阻塞，直到指定的文件描述符上发生就绪事件、超时时间到达或者被信号中断。

④一旦有事件发生，epoll_wait 返回就绪事件的数量，并将这些事件存储在传入的 events 数组中。

⑤应用程序可以遍历 events 数组，处理每个就绪事件。

⑥如果需要继续监听事件，可以再次调用 epoll_wait。

epoll_wait 的主要优势在于它可以高效处理大量的文件描述符，因为它不需要遍历所有文件描述符，只返回就绪的文件描述符，从而减少了系统调用的次数，提高了性能。

epoll实例

服务器端

#include <iostream>
#include <unistd.h>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/epoll.h>

#define MAXFD 10

using namespace std;

void epoll_add(int epfd, int fd)
{
    struct epoll_event ev;
    ev.data.fd = fd;
    ev.events = EPOLLIN; // r

    if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev) == -1)
    {
        cout << "epoll_ctl error" << endl;
    }
}

void epoll_del(int epfd, int fd)
{
    if (epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL) == -1)
    {
        cout << "epoll error1" << endl;
    }
}

void accept_client(int sockfd, int epfd)
{
    int c = accept(sockfd, NULL, NULL);
    if (c < 0)
    {
        return;
    }
    cout << "accept c=" << c << endl;

    epoll_add(epfd, c);
}

void recv_data(int c, int epfd)
{
    char buff[128] = {0};
    int n = recv(c, buff, 127, 0);
    if (n <= 0)
    {
        epoll_del(epfd, c);
        close(c);
        cout << "client close" << endl;
        return;
    }
    cout << "recv buff =" << buff << endl;
    send(c, "ok", 2, 0);
}

int socket_init()
{
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //创建套接字
    if (sockfd == -1)
    {
        return -1;
    }

    struct sockaddr_in saddr;
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET; //地址族
    saddr.sin_port = htons(6000); //端口号
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1"); //地址

    int res = bind(sockfd, (struct sockaddr *)&saddr, sizeof(saddr));

    if (res == -1)
    {
        cout << "bind error" << endl;
        return -1;
    }

    res = listen(sockfd, 5);

    if (res == -1)
    {
        return -1;
    }

    return sockfd;
}

int main()
{
    int sockfd = socket_init();
    if (sockfd == -1)
    {
        exit(1);
    }

    int epfd = epoll_create(MAXFD); //创建内核事件表
    if (epfd == -1)
    {
        exit(1);
    }

    epoll_add(epfd, sockfd);
    struct epoll_event evs[MAXFD]; //存放就绪描述符

    while (1)
    {
        int n = epoll_wait(epfd, evs, MAXFD, 5000); //阻塞，等就绪事件发生
        if (n < 0)
        {
            cout << "epoll error" << endl;
            continue;
        }
        else if (n == 0)
        {
            cout << "time out" << endl;
        }
        else
        {
            for (int i = 0; i < n; i++)
            {
                if (evs[i].events & EPOLLIN)
                {
                    if (evs[i].data.fd == sockfd) //新客户
                    {
                        accept_client(sockfd, epfd);
                    }
                    else //老客户
                    {
                        recv_data(evs[i].data.fd, epfd);
                    }
                }
            }
        }
    }
}

客户端

与select中的相同。

家妻鲁露
关注
专栏目录
网络编程----IO复用之select模型
hailong0715的专栏
04-06 3258
前一篇文章提到了，多线程/多进程虽然能够在一定程度上解决并发，但是由于进程/线程的切换消耗系统资源，多余并发量比较大的服务无法支持，因此为了解决大并发场景，需要一种能够支持更多并发的方法----IO复用， 与多线程/进程相比，IO复用最大的优点是避免了线程进程切换时产生的系统开销，内核不用创建线程也不用再维护这些线程了，这样就避免了很多不必要的开销。 本文介绍一种IO复用模型，select模型，
java高并发 -- 说说IO那点事儿
星辰大海，脚踏实地
08-30 2571
java IO, 同步和异步，阻塞和非阻塞，NIO,netty
网络编程--io多路复用
weixin_42335835的博客
12-30 328
阻塞io 和 非阻塞io 阻塞在哪里？阻塞在网络线程上，阻塞io操作 accept 、connect、 read、 write 例如 read函数会一直等待内核态中的读缓冲区有新的数据 int n = read(fd, buf, sz); 1.n = 0 表示连接断开 2.n < 0 errno = EWOULDBLOCK 表示读缓冲区没有数据 io函数到底做了哪些事情？1.检测连接数据状态 2.操作具体io io多路复用：会检测数据连接状态，并不操作具体的io；可以用一个线程检
网络编程--select实现IO复用
SNAKEpc12138的博客
05-18 751
select函数是实现IO复用服务器的关键，因此需要熟练掌握。这里也总结了select函数的使用步骤及示例模板，后续也可参考在实际开发时使用。步骤：①设置套接字②设置监视范围③设置超时④调用select函数⑤查看调用结果。
Linux编程--IO多路复用
xinqi_1的博客
06-17 2131
IO多路复用是指通过一种机制，使得单个进程可以监控多个文件描述符的可读、可写和异常等事件。常见的IO多路复用技术包括：select、poll、epoll等。在实际应用中，IO多路复用可以提高程序的运行效率和性能，减少系统开销，降低系统资源的使用率。它广泛应用于网络编程、服务器开发、操作系统等领域，可以帮助开发人员更好地处理大量的网络连接和数据请求。
python编程-IO模型
u014761412的博客
11-26 149
文章目录阻塞IO非阻塞IO非阻塞的TCP传输IO多路复用select机制poll机制epoll机制selector模块异步IO 阻塞IO 我们用一副图来描述阻塞IO的过程 阻塞IO会阻塞两段时间： 等待数据准备好 复制数据到进程中 非阻塞IO 和阻塞IO不同的是，在系统内核还未准备好数据的时候，应用程序会往下执行，但程序每隔一段时间，会不断向内核发起系统调用询问数据的准备情况，效率仍然不高。 直到有一次数据准备好之后，就会进行数据的复制操作将数据提交给应用程序进行使用 非阻塞的TCP传输 impor
linux网络编程-epoll多路复用
xiyangxiaoguo的博客
12-04 870
client.cpp -->client server.cpp -->server 在server中使用epoll来进行多路复用 client.cpp #include <stdlib.h> #include <stdio.h> #include <errno.h> #include <string.h> #include <string> #include <unistd.h> #include <net.
并发编程-线程
weixin_42583324的博客
06-19 1605
首先CPU、内存、I/O 设备的速度是有极大差异的，而我们日常的作业都是要操作到内存和IO的，如果没有多线程这个时候CPU就是处于空闲状态，使用多线程就是合理的利用CPU资源，从而提升作业效率。// 强制关闭线程池。threadFactory, // 线程工厂，可以自定义线程名称、优先级、是否守护线程等。线程是CPU调度的最小单位，进程是线程的集合，一个进程包含多个线程以及共享变量空间。线程空闲时间和单位，当线程数超过核心线程后创建了非核心线程，会在存活多久后被销毁。// 如果超时，强制关闭线程池。
Python-IO多路复用
蓝魔的博客
10-18 932
Python 是实现 IO 多路复用
网络编程：IO多路复用（五个IO模型）
weixin_71751116的博客
07-16 1149
1. 定义：单线程或单进程同时监测若干个文件描述符是否可以执行IO操作的能力2. 作用：应用程序通常需要处理来自多条事件流中的事件，比如我现在用的电脑，需要同时处理键盘鼠标的输入、中断信号等等事件，再比如web服务器如nginx，需要同时处理来来自N个客户端的事件。逻辑控制流在时间上的重叠叫做 并发而CPU单核在同一时刻只能做一件事情，一种解决办法是对CPU进行时分复用多个事件流将CPU切割成多个时间片，不同事件流的时间片交替进行。
IO模型-I/O复用模型
weixin_44614002的博客
07-17 1129
IO复用模型一般为异步阻塞IO，但select、poll、epoll本质上还是同步IO（都是需要读写事件就绪后再进行读写，而且整个读写的过程是阻塞的），真正意义上的异步IO是不需要负责进行读写操作的。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需要一次。​缺点单个进程能够监视的文件描述符的数量存在最大限制，在Linux上为1024，可以通过修改宏定义甚至重新编译内核的方式提升这一限制，但这样会造成效率的降低。.....
python网络编程详解
m0_59485658的博客
02-22 668
最近在看《UNIX网络编程 卷1》和《FREEBSD操作系统设计与实现》这两本书，我重点关注了TCP协议相关的内容，结合自己后台开发的经验，写下这篇文章，一方面是为了帮助有需要的人，更重要的是方便自己整理思路，加深理解。
Java并发编程-知识前瞻（第一章）
weixin_57646982的博客
05-08 322
前言： Java并发编程学习分享的目标： Java并发编程中常用的工具用途与用法； Java并发编程工具实现原理与设计思路； 并发编程中遇到的常见问题与解决方案； 根据实际情景选择更合适的工具完成高效的设计方案 学习分享团队： 学而思培优-运营研发团队Java并发编程分享小组： @沈健 @曹伟伟 @张俊勇 @田新文 @张晨 本章分享人：@张晨 学习分享大纲： 01 初识并发 什么是并发，什么是并行？ 用个JVM的例子来讲解，在垃圾回收器做并发标记..
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 997
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 980
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
pyqt瀑布流布局
weixin_54217201的博客
09-21 477
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 359
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
ubuntu22上C/C++程序使用weston+wayland+OpenGLES渲染
最新发布
Flying_Motor的博客
09-27 262
一，安装依赖软件：sudo apt install zlib1g-dev libssl-dev libgles2-mesa-dev libsystemd-dev libpng-dev libglib2.0-dev libwayland-dev weston libweston-9-dev。
c语言-数据类型
m0_69032433的博客
09-22 924
b --> 00000000 00000000 00000000 00001001 --> 9的原码,也是9的补码。... // 百度百科 https://baike.baidu.com/item/c%E8%AF%AD%E8%A8%80/105958?小数部分 1000 00000000 00000000 --> 1 * 2^(-1) --> 0.5。负整数的补码 --> -1 --> 取反 --> 绝对值的原码 --> 得到负数。
S7-300 PLC通过PROFINET IO实现分布式通信
通过以上步骤，工程师能够成功建立和维护S7-300的PROFINET IO通信网络，实现PLC与分布式IO设备之间的高效数据交换。这使得自动化系统能够快速响应生产需求，提高生产效率和灵活性。此外，由于PROFINET支持标准的IT...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值