LINUX網絡編程 IO 複用

原創 stecdeng 2018-08-27 19:16

參考《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驅動愛好者 服務器程序員溝通交流
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

java 網絡編程發展過程以及nio的特點

背景: 省分短信發送每天都差不多要1000W條上下,遇到特殊節假日和政府通告時量會更大!boss系統中存放的是短信發送內容,而真正完成發送短信指令動作是的華爲方做的短廳,這麼大的通信量選擇了netty來完成數據傳輸並自定義了一套基於net

哔哔小子 2020-07-08 09:25:14

Tomcat，servlet以及netty之間的簡單區別

Tomcat（這裏以tomcat代表web服務器）和Servlet對比： Tomcat可以理解成用於http平臺的服務器，能接受http的請求並分析。 Servlet是java內部的一種規範，準確的說，他可以對參數進行分析，創建對象然後返

哔哔小子 2020-07-08 09:25:14

配置Spring+hibernate使用ehcache作爲second-level cache

大量數據流動是web應用性能問題常見的原因，而緩存被廣泛的用於優化數據庫應用。cache 被設計爲通過保存從數據庫裏load的數據來減少應用和數據庫之間的數據流動。數據庫訪問只有當檢索的數據不在cache 裏可用時才必要。hiberna

jeff2007 2020-07-08 09:06:09

Struts ActionServlet 工作流程圖

一.Struts實現的MVC框架二.Struts的工作流程     對於採用Struts框架的Web應用,在Web應用啓動時就會加載並初始化Actio

jeff2007 2020-07-08 09:06:09

ip轉換爲數值 數值轉換爲ip c++

作爲練習，自己編了一個：   #include "stdafx.h" #include <iostream> #include <string> //#include <windows.h> using namespace std;

hityct1 2020-07-08 09:03:05

遠程複製文件（自動輸入密碼）

在程序中，已知寫入權限的密碼。  ---------------------------------------------------------------   1  使用  DWORD  WNetAddConnection2(   

aloking 2020-07-08 05:51:48

Linux epoll函數圖解

看到一篇不錯的文章《The method to epoll's madness》（作者：Cindy Sridharan）（原文鏈接）。 下面是摘錄： epoll stands for event poll and is a Linux s

buyicn 2020-07-08 03:51:47

Linux epoll和應用實例

1.高性能網路服務器編程用什麼技術？ Unix/Linux平臺：epoll Windows平臺：IOCP 2.Linux的epoll函數 epoll用到三個函數： int epoll_create(int size); int epol

buyicn 2020-07-08 03:51:47

Linux epoll API概述

大家是不是想知道，當我們在用戶空間調用linux epoll的三個函數 int epoll_create(int size); int epoll_ctl(int epfd, int op, int fd, struct epoll_ev

buyicn 2020-07-08 03:51:46

套接字簡介

套接字簡介套接字介紹什麼是套接字參考資料1參考資料2套接字的定義 套接字介紹 參考資料 套接字參考資料-1 套接字參考資料-2 什麼是套接字 參考資料1 Socket的英文原意是"插座"，作爲類UNIX系統的進程通信機制，它如

Number__Zero 2020-07-08 01:05:09

Qt socket傳送自定義結構體數據

簡介 在Socket中，數據一般是char型（一般情況下，其實最好是用uchar來傳輸，避免莫名其妙的錯誤，但用char也是可以的），而在Qt裏面可以使用QByteArray，這個在QSocket裏面，是一個神器，根據C++中ch

Uka Saegusa IN db 2020-07-08 00:48:32

UDP客戶端和服務端

IP地址（源IP，目的IP） 用來識別互聯網上一臺主機的位置 端口號（源端口，目的端口） 用來區分一臺主機上的哪個應用程序 （佔兩個字節的整數） 五元組： 源IP， 目的IP 源端口， 目的端口 協議類型 通過一個五元組表示一個唯

渴望成功！ 2020-07-08 00:37:26

TCP服務器（以Echo服務器爲例））

TCP服務器 他也涉及到兩個核心的類 ServerSocket Socket 這裏注意： UDP協議無連接，類似發微信，直接發就行 TCP協議有連接，類似打電話，要接通才能通話。 這裏依然用回顯服務器模式來體會TCP服務器： im

渴望成功！ 2020-07-08 00:37:26

HTTP協議初認識

TCP和HTTP協議使我們之後都比較重要的協議。目前用瀏覽器打開的一個網頁都是基於HTTP協議來進行傳輸的，APP內部數據大概率也是基於HTTP協議傳輸的。 接下來我們具體看HTTP協議的細節： URL：就是我們一直說的網址的專

渴望成功！ 2020-07-08 00:37:26

網絡編程：UDP編程

文章目錄基於UDP編程（服務器端持續監聽客戶端的請求）服務器端 server.cpp：客戶端 client.cpp： 基於UDP編程（服務器端持續監聽客戶端的請求） 服務器端 server.cpp： #include <stdio

图解编程 2020-07-08 00:31:04