LINUX网络编程 IO 复用

最新推荐文章于 2022-11-24 18:37:45 发布
原创 最新推荐文章于 2022-11-24 18:37:45 发布 · 708 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络编程 #EPOLL

参考《linux高性能服务器编程》

 

LINUX下处理多个连接时候，仅仅使用多线程和原始socket函数，效率十分低下

于是就出现了selelct poll  epoll等IO复用函数。

这里讨论性能最优的epoll IO复用

用户将需要关注的socket连接使用IO复用函数放进一个事件表中，每当事件表中有一个或者多个SOCKET连接出现读写请求时候，则进行处理

事件表使用一个额外的文件描述符来标识。文件描述符使用 epoll_create函数创建

#inlclude <sys/epoll.h>

int epoll_create(int size); size参数目前不起作用

 

操作事件表使用epoll_ctl函数进行控制

操作类型有以下3中 

EPOLL_CTL_ADD  EPOLL_CTL_MOD  EPOLL_CTL_DEL

 

在一段超时时间内等待事件表上的事件 使用epoll_wait();

函数范例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>
 
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10
 
int setnonblocking( int fd )
{
    int old_option = fcntl( fd, F_GETFL );
    int new_option = old_option | O_NONBLOCK;
    fcntl( fd, F_SETFL, new_option );
    return old_option;
}
 
void addfd( int epollfd, int fd, bool enable_et )
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN;
    if( enable_et )
    {
        event.events |= EPOLLET;
    }
    epoll_ctl( epollfd, EPOLL_CTL_ADD, fd, &event );
    setnonblocking( fd );
}
 
 
void et( epoll_event* events, int number, int epollfd, int listenfd )
{
    char buf[ BUFFER_SIZE ];
    for ( int i = 0; i < number; i++ )
    {
        int sockfd = events[i].data.fd;
        if ( sockfd == listenfd )
        {
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof( client_address );
            int connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength );
            addfd( epollfd, connfd, true );
        }
        else if ( events[i].events & EPOLLIN )
        {
            printf( "event trigger once\n" );
            while( 1 )
            {
                memset( buf, '\0', BUFFER_SIZE );
                int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
                if( ret < 0 )
                {
                    if( ( errno == EAGAIN ) || ( errno == EWOULDBLOCK ) )
                    {
                        printf( "read later\n" );
                        break;
                    }
                    close( sockfd );
                    break;
                }
                else if( ret == 0 )
                {
                    close( sockfd );
                }
                else
                {
                    printf( "get %d bytes of content: %s\n", ret, buf );
                }
            }
        }
        else
        {
            printf( "something else happened \n" );
        }
    }
}
 
int main( int argc, char* argv[] )
{
    if( argc <= 2 )
    {
        printf( "usage: %s ip_address port_number\n", basename( argv[0] ) );
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi( argv[2] );
 
    int ret = 0;
    struct sockaddr_in address;
    bzero( &address, sizeof( address ) );
    address.sin_family = AF_INET;
    inet_pton( AF_INET, ip, &address.sin_addr );
    address.sin_port = htons( port );
 
    int listenfd = socket( PF_INET, SOCK_STREAM, 0 );
    assert( listenfd >= 0 );
 
    ret = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
    assert( ret != -1 );
 
    ret = listen( listenfd, 5 );
    assert( ret != -1 );
 
    epoll_event events[ MAX_EVENT_NUMBER ];
    int epollfd = epoll_create( 5 );
    assert( epollfd != -1 );
    addfd( epollfd, listenfd, true );
 
    while( 1 )
    {
        int ret = epoll_wait( epollfd, events, MAX_EVENT_NUMBER, -1 );
        if ( ret < 0 )
        {
            printf( "epoll failure\n" );
            break;
        }
     
        et( events, ret, epollfd, listenfd );
    }
 
    close( listenfd );
    return 0;
}

　　

在尝试一个多线程代码;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>
 
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10
 
struct fds
{
   int epollfd;
   int sockfd;
};
 
void* worker( void* arg )
{
    int sockfd = ( (fds*)arg )->sockfd;
    int epollfd = ( (fds*)arg )->epollfd;
    printf( "start new thread to receive data on fd: %d\n", sockfd );
    char buf[ BUFFER_SIZE ];
    memset( buf, '\0', BUFFER_SIZE );
    while( 1 )
    {
        int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
        if( ret == 0 )
        {
            close( sockfd );
            printf( "foreiner closed the connection\n" );
            break;
        }
        else if( ret < 0 )
        {
            if( errno == EAGAIN )
            {
               // reset_oneshot( epollfd, sockfd );
                printf( "read later\n" );
                break;
            }
        }
        else
        {
            printf( "get content: %s\n", buf );
            sleep( 5 );
        }
    }
    printf( "end thread receiving data on fd: %d\n", sockfd );
}
 
int setnonblocking(int fd)
{
    int old_option = fcntl(fd,F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd,F_SETFL,new_option);
    return old_option;
}
 
void addfd(int epollfd,int fd,bool enable_et)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN;
     
    if(enable_et){
        event.events |= EPOLLET;
    }
    epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&event);
    setnonblocking(fd);
}
 
void et(epoll_event* events,int number,int epollfd,int listenfd){
    char buf[BUFFER_SIZE];
    for(int i = 0; i < number;i++){
        int sockfd = events[i].data.fd;
        if(sockfd == listenfd){
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof(client_address);
            int connfd = accept(listenfd,(struct sockaddr*)&client_address,&client_addrlength);
            addfd(epollfd,connfd,true);
        }else if(events[i].events & EPOLLIN){
            /*
            printf("event trigger once\n");
            while(1){
                memset(buf,'\0',BUFFER_SIZE);
                int ret = recv(sockfd,buf,BUFFER_SIZE-1,0);
                if(ret < 0){
                    if((errno == EAGAIN) || (errno == EWOULDBLOCK)){
                        printf("read later\n");
                        break;
                    }
                    close(sockfd);
                    break;
                }else if(ret == 0){
                    close(sockfd);
                }else{
                    printf("get %d bytes of content: %s \n",ret,buf);
                }
            }*/
             pthread_t thread;
                fds fds_for_new_worker;
                fds_for_new_worker.epollfd = epollfd;
                fds_for_new_worker.sockfd = sockfd;
                pthread_create( &thread, NULL, worker, ( void* )&fds_for_new_worker );
        }else{
            printf("something else happened \n");
        }
    }
}
 
int main()
{
    int ret = 0;
    struct sockaddr_in address;
    bzero(&address,sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET,"127.0.0.1",&address.sin_addr);
    address.sin_port = htons(1134);
     
    int listenfd = socket(AF_INET,SOCK_STREAM,0);
    assert(listenfd >= 0);
     
    ret = bind(listenfd,(struct sockaddr*)&address,sizeof(address));
    assert(ret != -1);
     
    ret = listen(listenfd,5);
    assert(ret != -1);
     
    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    addfd(epollfd,listenfd,true);
     
    while(1){
        int ret = epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-1);
        if(ret < 0){
            printf("epoll failure\n");
            break;
        }
        et(events,ret,epollfd,listenfd);
    }
     
    close(listenfd);
    return 0;
}

　　

多线程版本中 如果我们 连续多次输入会出现一个问题

如果我们连续多次在telnet的客户端输入

服务端会开启多个线程 接受这个socket的输入

显示如下：

fd: 5, sockfdget content: dfdsf
...
start new thread to receive data on fd: 5
fd: 5, sockfdget content: sd
...
start new thread to receive data on fd: 5
fd: 5, sockfdget content: sd
...
start new thread to receive data on fd: 5
fd: 5, sockfdget content: sd
...
start new thread to receive data on fd: 5
fd: 5, sockfdget content: sd
...
start new thread to receive data on fd: 5
fd: 5, sockfdget content: sd
...
start new thread to receive data on fd: 5
fd: 5, sockfdget content: sd

 

如果多个线程同时操作一个socket 可能出现各种意外情况

那么我们就需要设置socket的EPOLLONESHOT标志

对于连续操作，操作系统最多触发该socket上一次读写异常事件。

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>
 
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10
 
struct fds
{
   int epollfd;
   int sockfd;
};
 
void reset_oneshot( int epollfd, int fd )
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    epoll_ctl( epollfd, EPOLL_CTL_MOD, fd, &event );
}
 
 
void* worker( void* arg )
{
    int sockfd = ( (fds*)arg )->sockfd;
    int epollfd = ( (fds*)arg )->epollfd;
    printf( "start new thread to receive data on fd: %d\n", sockfd );
    char buf[ BUFFER_SIZE ];
    memset( buf, '\0', BUFFER_SIZE );
    while( 1 )
    {
        int ret = recv( sockfd, buf, BUFFER_SIZE-1, 0 );
        if( ret == 0 )
        {
            close( sockfd );
            printf( "foreiner closed the connection\n" );
            break;
        }
        else if( ret < 0 )
        {
            if( errno == EAGAIN )
            {
                reset_oneshot( epollfd, sockfd );
                printf( "read later\n" );
                break;
            }
        }
        else
        {
            printf( "get content: %s\n", buf );
            sleep( 5 );
        }
    }
    printf( "end thread receiving data on fd: %d\n", sockfd );
}
 
int setnonblocking(int fd)
{
    int old_option = fcntl(fd,F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd,F_SETFL,new_option);
    return old_option;
}
 
void addfd(int epollfd,int fd,bool setOneShot)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN;
     
 
    event.events |= EPOLLET;
    if(setOneShot)
        event.events |= EPOLLONESHOT;
    epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&event);
    setnonblocking(fd);
}
 
 
 
void et(epoll_event* events,int number,int epollfd,int listenfd){
    char buf[BUFFER_SIZE];
    for(int i = 0; i < number;i++){
        int sockfd = events[i].data.fd;
        if(sockfd == listenfd){
            struct sockaddr_in client_address;
            socklen_t client_addrlength = sizeof(client_address);
            int connfd = accept(listenfd,(struct sockaddr*)&client_address,&client_addrlength);
            addfd(epollfd,connfd,true);
        }else if(events[i].events & EPOLLIN){
            /*
            printf("event trigger once\n");
            while(1){
                memset(buf,'\0',BUFFER_SIZE);
                int ret = recv(sockfd,buf,BUFFER_SIZE-1,0);
                if(ret < 0){
                    if((errno == EAGAIN) || (errno == EWOULDBLOCK)){
                        printf("read later\n");
                        break;
                    }
                    close(sockfd);
                    break;
                }else if(ret == 0){
                    close(sockfd);
                }else{
                    printf("get %d bytes of content: %s \n",ret,buf);
                }
            }*/
             pthread_t thread;
                fds fds_for_new_worker;
                fds_for_new_worker.epollfd = epollfd;
                fds_for_new_worker.sockfd = sockfd;
                pthread_create( &thread, NULL, worker, ( void* )&fds_for_new_worker );
        }else{
            printf("something else happened \n");
        }
    }
}
 
int main()
{
    int ret = 0;
    struct sockaddr_in address;
    bzero(&address,sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET,"127.0.0.1",&address.sin_addr);
    address.sin_port = htons(1134);
     
    int listenfd = socket(AF_INET,SOCK_STREAM,0);
    assert(listenfd >= 0);
     
    ret = bind(listenfd,(struct sockaddr*)&address,sizeof(address));
    assert(ret != -1);
     
    ret = listen(listenfd,5);
    assert(ret != -1);
     
    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    addfd(epollfd,listenfd,false);
     
    while(1){
        int ret = epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-1);
        if(ret < 0){
            printf("epoll failure\n");
            break;
        }
        et(events,ret,epollfd,listenfd);
    }
     
    close(listenfd);
    return 0;
}

　　

 

输入

Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
1
2
3
4
5
sdfufghbskdjhkbaskjhbkjlsadvfblkajwsvdfbljkashdbkfjhasdfhasjkhD

输出

start new thread to receive data on fd: 5
get content: 1

get content: 2
3
4

get content: 5
sdfufg
get content: hbskdjhkb
get content: askjhbkjl
get content: sadvfblka
get content: jwsvdfblj
get content: kashdbkfj
get content: hasdfhasj
get content: khD
hasj
read later
end thread receiving data on fd: 5

技术博客 http://blog.youkuaiyun.com/stecdeng 技术交流群 群号码：324164944 欢迎c c++ windows驱动爱好者 服务器程序员沟通交流
Linux网络编程：I/O复用
凯凯在此
10-28 325
文章目录1. IO多路复用2. 分类2.1 Select模式2.2 Poll模式2.3 Epool模式 线程过多会占用很多的资源： 在空间方面，线程是有内存开销的，1000个线程就要512M或2G内存； 在时间方面，线程切换是有CPU开销的，大量线程会让时间花在上下文切换。 1. IO多路复用 IO多路复用： 多个网络连接复用一个IO线程 使用一个线程来检查I/O流（Socket）的就绪状态。通过记录跟踪每个I/O流(Socket)的状态，来同时管理多个I/O流 。 多个Socket复用功能是在内核驱
Linux下的三种 IO 复用
我要出家当道士
12-01 1678
本文详细介绍了 linux 下的三种 IO 复用技术，详细介绍了相关的函数 API 并提供了具体的使用 Demo。
42.Linux网络编程--IO多路复用（select poll epoll）
lzs940320的博客
05-10 2052
一. 预备知识 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），保证.
Linux C网络通信过程
GodNotAMen的博客
11-24 1110
逐步介绍Linux 网络连接的过程
select、poll、epoll详解
热门推荐
yygr的博客
04-18 1万+
https://blog.youkuaiyun.com/shawntime/article/details/115089947 IO读写基本原理 用户程序进行IO操作实际依赖于linux系统内核read()、write()函数 read()函数的调用并不是直接从网卡把数据读取到用户内存中，而是把内核缓冲区中的数据复制到用户缓冲区中 write()函数的调用也并不是直接把数据写入网卡中，而是把用户缓冲区的数据写入到内核缓冲区中 网卡与内核缓冲区数据的读写则是由操作系统内核完成 阻塞IO和非阻塞IO
网络编程实战之高级篇, 彻底解决面试C10k问题, 高并发服务器, IO多路复用, 同时监视多个IO事件
小杰312的博客
03-08 6129
网络编程实战之高级篇, 彻底解决面试C10k问题, 高并发服务器, IO多路复用, IO监视
Linux网络编程之IO复用循环服务器
08-26
### Linux网络编程之IO复用循环服务器 #### 一、引言 在现代网络应用开发中，服务器的设计面临着越来越高的并发请求处理需求。传统的简单循环服务器每次只能处理一个客户端请求，这种方式显然无法满足高并发场景的...
Linux网络编程之IO复用循环服务器.doc
最新发布
07-18
Linux网络编程中，传统的循环服务器每次只能处理一个客户端请求，而并发服务器能够通过创建多个进程或线程同时处理多个客户端请求。然而，进程或线程的创建与切换会带来系统开销，特别是当客户端数量增多时，系统...
Linux网络编程之IO复用循环服务器.pdf
09-28
Linux网络编程之IO复用循环服务器.pdf Linux网络编程之IO复用循环服务器是指一种高效的服务器设计模式，它可以高效地处理大量客户端的请求。这种服务器设计模式可以分为两个线程：客户端连接处理线程和业务处理线程...
多进程并发编程
上官宏竹的专栏
09-17 577
exit()函数用于终止调用进程。关闭所有子进程打开的描述符，向父进程发送SIGCHLD信号，并返回状态。 父进程可通过调用wait()或waitpid()函数获得子进程的终止信息。{ if(listen(listenfd,BACKLOG)== -1){ perror("listen() error\n"); exit(1); } len=s
网络
danxinhaitang_c的博客
04-06 419
系统底层的Socket编程函数 常用开源Socket库 网络编程的4种IO模型 1、Select模型 2、WSAAsyncSelect模型 3、WSAEventSelect模型 4、完成端口模型 局域网中最常用的有三个网络协议:MICROSOFT的NETBEUI、NOVELL的IPX/SPX和TCP/IP协议 通信协议。主要是对信息传输的速率、传输代码、代码结构、传输控制步骤、出错控制等作出规定并制定出标准。 C/...
Linux TCP server系列（4）-浅谈listen与大并发TCP连接
newyoung518的专栏
06-05 1891
背景：    服务器在调用listen和accept后，就会阻塞在accept函数上，accpet函数返回后循环调用accept函数等待客户的TCP连接。如果这时候又大量的用户并发发起connect连接，那么在listen有队列上限(最大可接受TCP的连接数)的情况下，有多少个connect会成功了。试验证明，当连接数远远高于listen的可连接数上限时，客户端的大部分TCP请求会被抛弃，只有当
linux中脚本return,Shell脚本return、echo、printf
weixin_42466331的博客
05-12 980
ehco和returnreturn 返回的是状态码，函数结束return不返回函数返回值可以在前面用 echo 返回函数返回值，return 返回指定函数退出状态码echo 返回的是函数返回值，函数退出状态码是函数最后一条命令的退出状态码test1.sh#!/bin/bashfunctiontest(){echo200}ret=$(test)echo"####$?"echo"*****...
TCP协议的认识及简单实现
YANG_1605的博客
01-21 548
一、TCP协议 （一）具体定义：TCP协议即传输控制协议，是一种面向连接的、可靠的、基于字节流的传输层通信协议。 （二）C/S模型：客户端 被动通讯方 数据提供者 服务器端 主动通讯方 数据获取者 （三）服务特点： 1．面向连接的传输； 2．端到端的通信； ...
实例说明listen()函数第二个参数的意义与用法
kongxian2007的专栏
10-15 1万+
我们先来看结果: Client: #include #include #include #include #include #include int main(int argc,char** argv) { int ret; int sockfd = socket(AF_INET,SOCK_STREAM,0); if (sockfd == -1) { printf("
linux 服务器端listen(5)
chenliang0224的专栏
07-01 2192
1. 前言
linux网络通信socket
weixin_42418864的博客
05-30 592
socket也称作“套接字”，描述了计算机的IP地址和端口，运行在计算机中的程序之间采用socket进行数据通信。通信的两端都有socket，它是一个通道，数据在两个socket之间进行传输。 socket把复杂的TCP/IP协议族隐藏在socket接口后面，用好socket相关的函数，就可以完成数据通信。 ...
非阻塞accept
了解的越多，越知道自己的无知
07-31 2661
先说一下为什么要使用非阻塞的accept.
Linux下TCP客户端和服务器代码编写
Leonban的博客
10-16 1721
一、各部分功能： 服务器：主动建立服务程序，等待客户端连接，相应客户端的请求 客户端：当有需求时，主动连接服务器，发出服务请求 二、书写顺序： 1、先写服务器程序，然后用telnet 模拟客户端远程登录 2、再写客户端程序，登录写好的服务器 3、最后写客户端和服务器通信的语句。 三、先写服务器程序，然后用telnet 模拟客户端远程登录 1、socket int sock
Linux网络编程高级课程课件：并发与IO复用
3. IO复用 I/O复用是一种允许程序监视多个文件描述符的技术，以获取它们的状态变化，包括读、写或异常条件。这种方法在处理大量并发连接时尤其有用，因为它可以减少系统调用的次数，提高资源使用效率。epoll是Linux...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值