最近很多Golang小夥伴面試居然被問到epoll？很是頭疼？
猜測面試官應該是一個古老的C/C++ Coder吧
那麼，對於Gopher來說，或者後端開發者來說，尤其是做伺服器開發，不管從事什麼程式語言，epoll確實都應該是一個必備的知識領域。
本篇文章就是可以讓你快速瞭解什麼是epoll以及它的作用？
一、流？I/O操作? 阻塞？
(1) 流
- 可以進行I/O操作的核心物件
- 檔案、管道、套接字……
- 流的入口：檔案描述符(fd)
(2) I/O操作
所有對流的讀寫操作，我們都可以稱之為IO操作。
當一個流中， 在沒有資料read的時候，或者說在流中已經寫滿了資料，再write，我們的IO操作就會出現一種現象，就是阻塞現象，如下圖。
(3) 阻塞
阻塞場景: 你有一份快遞，家裡有個座機，快遞到了主動給你打電話，期間你可以休息。
非阻塞，忙輪詢場景: 你性子比較急躁， 每分鐘就要打電話詢問快遞小哥一次， 到底有沒有到，快遞員接你電話要停止運輸，這樣很耽誤快遞小哥的運輸速度。
- 阻塞等待
空出大腦可以安心睡覺, 不影響快遞員工作（不佔用CPU寶貴的時間片）。
- 非阻塞，忙輪詢
浪費時間，浪費電話費，佔用快遞員時間（佔用CPU，系統資源）。
很明顯，阻塞等待這種方式，對於通訊上是有明顯優勢的， 那麼它有哪些弊端呢？
二、解決阻塞死等待的辦法
阻塞死等待的缺點
也就是同一時刻，你只能被動的處理一個快遞員的簽收業務，其他快遞員打電話打不進來，只能乾瞪眼等待。那麼解決這個問題，家裡多買N個座機， 但是依然是你一個人接，也處理不過來，需要用影分身術建立都個自己來接電話(採用多執行緒或者多程式）來處理。
這種方式就是沒有多路IO複用的情況的解決方案， 但是在單執行緒計算機時代(無法影分身)，這簡直是災難。
那麼如果我們不借助影分身的方式(多執行緒/多程式)，該如何解決阻塞死等待的方法呢？
辦法一：非阻塞、忙輪詢
while true {
for i in 流[] {
if i has 資料 {
讀 或者 其他處理
}
}
}非阻塞忙輪詢的方式，可以讓使用者分別與每個快遞員取得聯絡，巨集觀上來看，是同時可以與多個快遞員溝通(併發效果)、 但是快遞員在於使用者溝通時耽誤前進的速度(浪費CPU)。
辦法二：select
我們可以開設一個代收網點，讓快遞員全部送到代收點。這個網店管理員叫select。這樣我們就可以在家休息了，麻煩的事交給select就好了。當有快遞的時候，select負責給我們打電話，期間在家休息睡覺就好了。
但select 代收員比較懶，她記不住快遞員的單號，還有快遞貨物的數量。她只會告訴你快遞到了，但是是誰到的，你需要挨個快遞員問一遍。
while true {
select(流[]); //阻塞
//有訊息抵達
for i in 流[] {
if i has 資料 {
讀 或者 其他處理
}
}
}辦法三：epoll
epoll的服務態度要比select好很多，在通知我們的時候，不僅告訴我們有幾個快遞到了，還分別告訴我們是誰誰誰。我們只需要按照epoll給的答覆，來詢問快遞員取快遞即可。
while true {
可處理的流[] = epoll_wait(epoll_fd); //阻塞
//有訊息抵達，全部放在 “可處理的流[]”中
for i in 可處理的流[] {
讀 或者 其他處理
}
}三、epoll？
- 與select，poll一樣，對I/O多路複用的技術
- 只關心“活躍”的連結，無需遍歷全部描述符集合
- 能夠處理大量的連結請求(系統可以開啟的檔案數目)
四、epoll的API
(1) 建立EPOLL
/**
* @param size 告訴核心監聽的數目
*
* @returns 返回一個epoll控制程式碼（即一個檔案描述符）
*/
int epoll_create(int size);使用
int epfd = epoll_create(1000);
建立一個epoll控制程式碼，實際上是在核心空間，建立一個root根節點，這個根節點的關係與epfd相對應。
(2) 控制EPOLL
/**
* @param epfd 用epoll_create所建立的epoll控制程式碼
* @param op 表示對epoll監控描述符控制的動作
*
* EPOLL_CTL_ADD(註冊新的fd到epfd)
* EPOLL_CTL_MOD(修改已經註冊的fd的監聽事件)
* EPOLL_CTL_DEL(epfd刪除一個fd)
*
* @param fd 需要監聽的檔案描述符
* @param event 告訴核心需要監聽的事件
*
* @returns 成功返回0，失敗返回-1, errno檢視錯誤資訊
*/
int epoll_ctl(int epfd, int op, int fd,
struct epoll_event *event);
struct epoll_event {
__uint32_t events; /* epoll 事件 */
epoll_data_t data; /* 使用者傳遞的資料 */
}
/*
* events : {EPOLLIN, EPOLLOUT, EPOLLPRI,
EPOLLHUP, EPOLLET, EPOLLONESHOT}
*/
typedef union epoll_data {
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;使用
struct epoll_event new_event;
new_event.events = EPOLLIN | EPOLLOUT;
new_event.data.fd = 5;
epoll_ctl(epfd, EPOLL_CTL_ADD, 5, &new_event); 建立一個使用者態的事件，繫結到某個fd上，然後新增到核心中的epoll紅黑樹中。
(3) 等待EPOLL
/**
*
* @param epfd 用epoll_create所建立的epoll控制程式碼
* @param event 從核心得到的事件集合
* @param maxevents 告知核心這個events有多大,
* 注意: 值 不能大於建立epoll_create()時的size.
* @param timeout 超時時間
* -1: 永久阻塞
* 0: 立即返回，非阻塞
* >0: 指定微秒
*
* @returns 成功: 有多少檔案描述符就緒,時間到時返回0
* 失敗: -1, errno 檢視錯誤
*/
int epoll_wait(int epfd, struct epoll_event *event,
int maxevents, int timeout);使用
struct epoll_event my_event[1000];
int event_cnt = epoll_wait(epfd, my_event, 1000, -1); epoll_wait是一個阻塞的狀態，如果核心檢測到IO的讀寫響應，會拋給上層的epoll_wait, 返回給使用者態一個已經觸發的事件佇列，同時阻塞返回。開發者可以從佇列中取出事件來處理，其中事件裡就有繫結的對應fd是哪個(之前新增epoll事件的時候已經繫結)。
(4) 使用epoll程式設計主流程骨架
int epfd = epoll_crete(1000);
//將 listen_fd 新增進 epoll 中
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd,&listen_event);
while (1) {
//阻塞等待 epoll 中 的fd 觸發
int active_cnt = epoll_wait(epfd, events, 1000, -1);
for (i = 0 ; i < active_cnt; i++) {
if (evnets[i].data.fd == listen_fd) {
//accept. 並且將新accept 的fd 加進epoll中.
}
else if (events[i].events & EPOLLIN) {
//對此fd 進行讀操作
}
else if (events[i].events & EPOLLOUT) {
//對此fd 進行寫操作
}
}
}9、Golang中的Channel底層深度剖析
首先宣告，本文不介紹channel的基礎語法和使用場景，如果想golang中的channel的基礎語法其他地方有很多地方介紹。這裡只介紹channel的一些底層實現原理的剖析。
(1)Channel特性
首先，我們先複習一下Channel都有哪些特性？
給一個 nil channel 傳送資料，造成永遠阻塞
從一個 nil channel 接收資料，造成永遠阻塞
給一個已經關閉的 channel 傳送資料，引起 panic
從一個已經關閉的 channel 接收資料，如果緩衝區中為空，則返回一個零值
無緩衝的channel是同步的，而有緩衝的channel是非同步的
以上5個特性是死東西，也可以通過口訣來記憶：“空讀寫阻塞，寫關閉異常，讀關閉空零”。
下面以簡單的示例來演示Go如何通過channel來實現通訊。
package main
import (
"fmt"
"time"
)
func goRoutineA(a <-chan int) {
val := <-a
fmt.Println("goRoutineA received the data", val)
}
func goRoutineB(b chan int) {
val := <-b
fmt.Println("goRoutineB received the data", val)
}
func main() {
ch := make(chan int, 3)
go goRoutineA(ch)
go goRoutineB(ch)
ch <- 3
time.Sleep(time.Second * 1)
}五、epoll的觸發模式
(1) 水平觸發
水平觸發的主要特點是，如果使用者在監聽epoll事件，當核心有事件的時候，會拷貝給使用者態事件，但是如果使用者只處理了一次，那麼剩下沒有處理的會在下一次epoll_wait再次返回該事件。
這樣如果使用者永遠不處理這個事件，就導致每次都會有該事件從核心到使用者的拷貝，耗費效能，但是水平觸發相對安全，最起碼事件不會丟掉，除非使用者處理完畢。
(2) 邊緣觸發
邊緣觸發，相對跟水平觸發相反，當核心有事件到達， 只會通知使用者一次，至於使用者處理還是不處理，以後將不會再通知。這樣減少了拷貝過程，增加了效能，但是相對來說，如果使用者馬虎忘記處理，將會產生事件丟的情況。
五、簡單的epoll伺服器(C語言)
(1) 服務端
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#define SERVER_PORT (7778)
#define EPOLL_MAX_NUM (2048)
#define BUFFER_MAX_LEN (4096)
char buffer[BUFFER_MAX_LEN];
void str_toupper(char *str)
{
int i;
for (i = 0; i < strlen(str); i ++) {
str[i] = toupper(str[i]);
}
}
int main(int argc, char **argv)
{
int listen_fd = 0;
int client_fd = 0;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
socklen_t client_len;
int epfd = 0;
struct epoll_event event, *my_events;
/ socket
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
// bind
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(SERVER_PORT);
bind(listen_fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
// listen
listen(listen_fd, 10);
// epoll create
epfd = epoll_create(EPOLL_MAX_NUM);
if (epfd < 0) {
perror("epoll create");
goto END;
}
// listen_fd -> epoll
event.events = EPOLLIN;
event.data.fd = listen_fd;
if (epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &event) < 0) {
perror("epoll ctl add listen_fd ");
goto END;
}
my_events = malloc(sizeof(struct epoll_event) * EPOLL_MAX_NUM);
while (1) {
// epoll wait
int active_fds_cnt = epoll_wait(epfd, my_events, EPOLL_MAX_NUM, -1);
int i = 0;
for (i = 0; i < active_fds_cnt; i++) {
// if fd == listen_fd
if (my_events[i].data.fd == listen_fd) {
//accept
client_fd = accept(listen_fd, (struct sockaddr*)&client_addr, &client_len);
if (client_fd < 0) {
perror("accept");
continue;
}
char ip[20];
printf("new connection[%s:%d]\n", inet_ntop(AF_INET, &client_addr.sin_addr, ip, sizeof(ip)), ntohs(client_addr.sin_port));
event.events = EPOLLIN | EPOLLET;
event.data.fd = client_fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &event);
}
else if (my_events[i].events & EPOLLIN) {
printf("EPOLLIN\n");
client_fd = my_events[i].data.fd;
// do read
buffer[0] = '\0';
int n = read(client_fd, buffer, 5);
if (n < 0) {
perror("read");
continue;
}
else if (n == 0) {
epoll_ctl(epfd, EPOLL_CTL_DEL, client_fd, &event);
close(client_fd);
}
else {
printf("[read]: %s\n", buffer);
buffer[n] = '\0';
#if 1
str_toupper(buffer);
write(client_fd, buffer, strlen(buffer));
printf("[write]: %s\n", buffer);
memset(buffer, 0, BUFFER_MAX_LEN);
#endif
/*
event.events = EPOLLOUT;
event.data.fd = client_fd;
epoll_ctl(epfd, EPOLL_CTL_MOD, client_fd, &event);
*/
}
}
else if (my_events[i].events & EPOLLOUT) {
printf("EPOLLOUT\n");
/*
client_fd = my_events[i].data.fd;
str_toupper(buffer);
write(client_fd, buffer, strlen(buffer));
printf("[write]: %s\n", buffer);
memset(buffer, 0, BUFFER_MAX_LEN);
event.events = EPOLLIN;
event.data.fd = client_fd;
epoll_ctl(epfd, EPOLL_CTL_MOD, client_fd, &event);
*/
}
}
}
END:
close(epfd);
close(listen_fd);
return 0;
}(2) 客戶端
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#define MAX_LINE (1024)
#define SERVER_PORT (7778)
void setnoblocking(int fd)
{
int opts = 0;
opts = fcntl(fd, F_GETFL);
opts = opts | O_NONBLOCK;
fcntl(fd, F_SETFL);
}
int main(int argc, char **argv)
{
int sockfd;
char recvline[MAX_LINE + 1] = {0};
struct sockaddr_in server_addr;
if (argc != 2) {
fprintf(stderr, "usage ./client <SERVER_IP>\n");
exit(0);
}
// 建立socket
if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
fprintf(stderr, "socket error");
exit(0);
}
// server addr 賦值
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERVER_PORT);
if (inet_pton(AF_INET, argv[1], &server_addr.sin_addr) <= 0) {
fprintf(stderr, "inet_pton error for %s", argv[1]);
exit(0);
}
// 連結服務端
if (connect(sockfd, (struct sockaddr*) &server_addr, sizeof(server_addr)) < 0) {
perror("connect");
fprintf(stderr, "connect error\n");
exit(0);
}
setnoblocking(sockfd);
char input[100];
int n = 0;
int count = 0;
// 不斷的從標準輸入字串
while (fgets(input, 100, stdin) != NULL)
{
printf("[send] %s\n", input);
n = 0;
// 把輸入的字串傳送 到 伺服器中去
n = send(sockfd, input, strlen(input), 0);
if (n < 0) {
perror("send");
}
n = 0;
count = 0;
// 讀取 伺服器返回的資料
while (1)
{
n = read(sockfd, recvline + count, MAX_LINE);
if (n == MAX_LINE)
{
count += n;
continue;
}
else if (n < 0){
perror("recv");
break;
}
else {
count += n;
recvline[count] = '\0';
printf("[recv] %s\n", recvline);
break;
}
}
}
return 0;
}###關於作者：
mail: danbing.at@gmail.com
github: https://github.com/aceld
原創書籍gitbook: http://legacy.gitbook.com/@aceld
創作不易, 共同學習進步, 歡迎關注作者, 回覆”zinx”有好禮
文章推薦
開源軟體作品
(原創開源)Zinx-基於Golang輕量級伺服器併發框架-完整版(附教程視訊)
(原創開源)Lars-基於C++負載均衡遠端排程系統-完整版
精選文章
典藏版-Golang排程器GMP原理與排程全分析
最常用的除錯 golang 的 bug 以及效能問題的實踐方法？
Golang中的區域性變數“何時棧?何時堆?”
使用Golang的interface介面設計原則
深入淺出Golang的協程池設計
Go語言構建微服務一站式解決方案
本作品採用《CC 協議》，轉載必須註明作者和本文連結