LINUX网络编程 IO 复用

最新推荐文章于 2022-11-24 18:37:45 发布
最新推荐文章于 2022-11-24 18:37:45 发布
阅读量661 收藏
点赞数
分类专栏： 网络编程 Linux系统 文章标签： 网络编程 EPOLL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stecdeng/article/details/57415782
版权

参考《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.csdn.net/stecdeng 技术交流群 群号码：324164944 欢迎c c++ windows驱动爱好者 服务器程序员沟通交流
stecdeng
关注
专栏目录
Linux网络编程 | IO复用 : epoll系列系统调用详解
ZY-JIMMY
04-19 2027
内核事件表、操作函数epoll_ctl 、epoll_wait函数 、使用epoll系列系统调用实现多客户/服务器 、LT 和 ET模式
Linux网络编程：I/O复用
凯凯在此
10-28 275
文章目录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复用功能是在内核驱
42.Linux网络编程--IO多路复用（select poll epoll）
lzs940320的博客
05-10 1944
一. 预备知识 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 989
逐步介绍Linux 网络连接的过程
select、poll、epoll详解
热门推荐
yygr的博客
04-18 1万+
https://blog.csdn.net/shawntime/article/details/115089947 IO读写基本原理 用户程序进行IO操作实际依赖于linux系统内核read()、write()函数 read()函数的调用并不是直接从网卡把数据读取到用户内存中，而是把内核缓冲区中的数据复制到用户缓冲区中 write()函数的调用也并不是直接把数据写入网卡中，而是把用户缓冲区的数据写入到内核缓冲区中 网卡与内核缓冲区数据的读写则是由操作系统内核完成 阻塞IO和非阻塞IO
网络编程实战之高级篇, 彻底解决面试C10k问题, 高并发服务器, IO多路复用, 同时监视多个IO事件
小杰312的博客
03-08 5731
网络编程实战之高级篇, 彻底解决面试C10k问题, 高并发服务器, IO多路复用, IO监视
Linux网络编程之IO复用循环服务器
08-26
### Linux网络编程之IO复用循环服务器 #### 一、引言 在现代网络应用开发中，服务器的设计面临着越来越高的并发请求处理需求。传统的简单循环服务器每次只能处理一个客户端请求，这种方式显然无法满足高并发场景的...
Linux网络编程之IO复用循环服务器.pdf
最新发布
09-28
Linux网络编程之IO复用循环服务器.pdf Linux网络编程之IO复用循环服务器是指一种高效的服务器设计模式，它可以高效地处理大量客户端的请求。这种服务器设计模式可以分为两个线程：客户端连接处理线程和业务处理线程...
Linux网络编程之IO复用循环服务器.doc
09-28
Linux网络编程中的IO复用循环服务器是一种高效处理并发网络请求的模型，旨在克服简单循环服务器和并发服务器的局限性。简单循环服务器每次只能处理一个请求，而并发服务器通过多线程或多进程处理多个请求，但伴随着...
Linux IO多路复用之epoll网络编程
09-15
在Linux系统中，IO多路复用是一种高效的网络编程技术，它允许多个网络连接在同一时间进行处理，而不需要为每个连接创建单独的线程或进程。`epoll`是Linux内核提供的一种IO多路复用机制，特别适合于高并发、高性能的...
网络
danxinhaitang_c的博客
04-06 315
系统底层的Socket编程函数 常用开源Socket库 网络编程的4种IO模型 1、Select模型 2、WSAAsyncSelect模型 3、WSAEventSelect模型 4、完成端口模型 局域网中最常用的有三个网络协议:MICROSOFT的NETBEUI、NOVELL的IPX/SPX和TCP/IP协议 通信协议。主要是对信息传输的速率、传输代码、代码结构、传输控制步骤、出错控制等作出规定并制定出标准。 C/...
Linux Shell重定向介绍
^_^TaeYang-Jade^_^
01-30 404
Linux文件描述符 可以理解为linux跟踪打开文件，而分配的一个数字，这个数字类似C语言操作文件时候的句柄，通过句柄就可以实现文件的读写操作。用户可以自定义文件描述符范围：3-num (ulimit -n) Linux启动后，会默认打开3个文件描述符，分别是： 标准输入standard input 0 正确输出standard output 1 错误输出error out...
linux中脚本return,Shell脚本return、echo、printf
weixin_42466331的博客
05-12 911
ehco和returnreturn 返回的是状态码，函数结束return不返回函数返回值可以在前面用 echo 返回函数返回值，return 返回指定函数退出状态码echo 返回的是函数返回值，函数退出状态码是函数最后一条命令的退出状态码test1.sh#!/bin/bashfunctiontest(){echo200}ret=$(test)echo"####$?"echo"*****...
TCP协议的认识及简单实现
YANG_1605的博客
01-21 488
一、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 2077
1. 前言
非阻塞accept
了解的越多，越知道自己的无知
07-31 2583
先说一下为什么要使用非阻塞的accept.
Linux下TCP客户端和服务器代码编写
Leonban的博客
10-16 1664
一、各部分功能： 服务器：主动建立服务程序，等待客户端连接，相应客户端的请求 客户端：当有需求时，主动连接服务器，发出服务请求 二、书写顺序： 1、先写服务器程序，然后用telnet 模拟客户端远程登录 2、再写客户端程序，登录写好的服务器 3、最后写客户端和服务器通信的语句。 三、先写服务器程序，然后用telnet 模拟客户端远程登录 1、socket int sock
Linux C编程：IO、进程与网络详解
本资源是一份深入讲解Linux C应用程序编程的教程，涵盖了标准IO与文件IO、C库的制作（静态库与动态库）、进程管理和线程相关知识。以下是各部分的详细知识点： 1. 标准IO与文件IO - 标准IO：介绍基础概念，包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值