薯條

薯條 查看完整檔案

北京編輯  |  填寫畢業院校  |  填寫所在公司/組織填寫個人主網站
編輯

個人微信公眾號:「薯條的自我修養」,歡迎關注

個人動態

薯條 贊了文章 · 2月23日

Linux IO模式及 select、poll、epoll詳解

注:本文是對眾多博客的學習和總結,可能存在理解錯誤。請帶著懷疑的眼光,同時如果有錯誤希望能指出。

同步IO和異步IO,阻塞IO和非阻塞IO分別是什么,到底有什么區別?不同的人在不同的上下文下給出的答案是不同的。所以先限定一下本文的上下文。

本文討論的背景是Linux環境下的network IO。

一 概念說明

在進行解釋之前,首先要說明幾個概念:
- 用戶空間和內核空間
- 進程切換
- 進程的阻塞
- 文件描述符
- 緩存 I/O

用戶空間與內核空間

現在操作系統都是采用虛擬存儲器,那么對32位操作系統而言,它的尋址空間(虛擬存儲空間)為4G(2的32次方)。操作系統的核心是內核,獨立于普通的應用程序,可以訪問受保護的內存空間,也有訪問底層硬件設備的所有權限。為了保證用戶進程不能直接操作內核(kernel),保證內核的安全,操心系統將虛擬空間劃分為兩部分,一部分為內核空間,一部分為用戶空間。針對linux操作系統而言,將最高的1G字節(從虛擬地址0xC0000000到0xFFFFFFFF),供內核使用,稱為內核空間,而將較低的3G字節(從虛擬地址0x00000000到0xBFFFFFFF),供各個進程使用,稱為用戶空間。

進程切換

為了控制進程的執行,內核必須有能力掛起正在CPU上運行的進程,并恢復以前掛起的某個進程的執行。這種行為被稱為進程切換。因此可以說,任何進程都是在操作系統內核的支持下運行的,是與內核緊密相關的。

從一個進程的運行轉到另一個進程上運行,這個過程中經過下面這些變化:
1. 保存處理機上下文,包括程序計數器和其他寄存器。
2. 更新PCB信息。
3. 把進程的PCB移入相應的隊列,如就緒、在某事件阻塞等隊列。
4. 選擇另一個進程執行,并更新其PCB。
5. 更新內存管理的數據結構。
6. 恢復處理機上下文。

注:總而言之就是很耗資源,具體的可以參考這篇文章:進程切換

進程的阻塞

正在執行的進程,由于期待的某些事件未發生,如請求系統資源失敗、等待某種操作的完成、新數據尚未到達或無新工作做等,則由系統自動執行阻塞原語(Block),使自己由運行狀態變為阻塞狀態??梢?,進程的阻塞是進程自身的一種主動行為,也因此只有處于運行態的進程(獲得CPU),才可能將其轉為阻塞狀態。當進程進入阻塞狀態,是不占用CPU資源的。

文件描述符fd

文件描述符(File descriptor)是計算機科學中的一個術語,是一個用于表述指向文件的引用的抽象化概念。

文件描述符在形式上是一個非負整數。實際上,它是一個索引值,指向內核為每一個進程所維護的該進程打開文件的記錄表。當程序打開一個現有文件或者創建一個新文件時,內核向進程返回一個文件描述符。在程序設計中,一些涉及底層的程序編寫往往會圍繞著文件描述符展開。但是文件描述符這一概念往往只適用于UNIX、Linux這樣的操作系統。

緩存 I/O

緩存 I/O 又被稱作標準 I/O,大多數文件系統的默認 I/O 操作都是緩存 I/O。在 Linux 的緩存 I/O 機制中,操作系統會將 I/O 的數據緩存在文件系統的頁緩存( page cache )中,也就是說,數據會先被拷貝到操作系統內核的緩沖區中,然后才會從操作系統內核的緩沖區拷貝到應用程序的地址空間。

緩存 I/O 的缺點:
數據在傳輸過程中需要在應用程序地址空間和內核進行多次數據拷貝操作,這些數據拷貝操作所帶來的 CPU 以及內存開銷是非常大的。

二 IO模式

剛才說了,對于一次IO訪問(以read舉例),數據會先被拷貝到操作系統內核的緩沖區中,然后才會從操作系統內核的緩沖區拷貝到應用程序的地址空間。所以說,當一個read操作發生時,它會經歷兩個階段:
1. 等待數據準備 (Waiting for the data to be ready)
2. 將數據從內核拷貝到進程中 (Copying the data from the kernel to the process)

正式因為這兩個階段,linux系統產生了下面五種網絡模式的方案。
- 阻塞 I/O(blocking IO)
- 非阻塞 I/O(nonblocking IO)
- I/O 多路復用( IO multiplexing)
- 信號驅動 I/O( signal driven IO)
- 異步 I/O(asynchronous IO)

注:由于signal driven IO在實際中并不常用,所以我這只提及剩下的四種IO Model。

阻塞 I/O(blocking IO)

在linux中,默認情況下所有的socket都是blocking,一個典型的讀操作流程大概是這樣:
clipboard.png

當用戶進程調用了recvfrom這個系統調用,kernel就開始了IO的第一個階段:準備數據(對于網絡IO來說,很多時候數據在一開始還沒有到達。比如,還沒有收到一個完整的UDP包。這個時候kernel就要等待足夠的數據到來)。這個過程需要等待,也就是說數據被拷貝到操作系統內核的緩沖區中是需要一個過程的。而在用戶進程這邊,整個進程會被阻塞(當然,是進程自己選擇的阻塞)。當kernel一直等到數據準備好了,它就會將數據從kernel中拷貝到用戶內存,然后kernel返回結果,用戶進程才解除block的狀態,重新運行起來。

所以,blocking IO的特點就是在IO執行的兩個階段都被block了。

非阻塞 I/O(nonblocking IO)

linux下,可以通過設置socket使其變為non-blocking。當對一個non-blocking socket執行讀操作時,流程是這個樣子:
clipboard.png

當用戶進程發出read操作時,如果kernel中的數據還沒有準備好,那么它并不會block用戶進程,而是立刻返回一個error。從用戶進程角度講 ,它發起一個read操作后,并不需要等待,而是馬上就得到了一個結果。用戶進程判斷結果是一個error時,它就知道數據還沒有準備好,于是它可以再次發送read操作。一旦kernel中的數據準備好了,并且又再次收到了用戶進程的system call,那么它馬上就將數據拷貝到了用戶內存,然后返回。

所以,nonblocking IO的特點是用戶進程需要不斷的主動詢問kernel數據好了沒有。

I/O 多路復用( IO multiplexing)

IO multiplexing就是我們說的select,poll,epoll,有些地方也稱這種IO方式為event driven IO。select/epoll的好處就在于單個process就可以同時處理多個網絡連接的IO。它的基本原理就是select,poll,epoll這個function會不斷的輪詢所負責的所有socket,當某個socket有數據到達了,就通知用戶進程。

clipboard.png

當用戶進程調用了select,那么整個進程會被block,而同時,kernel會“監視”所有select負責的socket,當任何一個socket中的數據準備好了,select就會返回。這個時候用戶進程再調用read操作,將數據從kernel拷貝到用戶進程。

所以,I/O 多路復用的特點是通過一種機制一個進程能同時等待多個文件描述符,而這些文件描述符(套接字描述符)其中的任意一個進入讀就緒狀態,select()函數就可以返回。

這個圖和blocking IO的圖其實并沒有太大的不同,事實上,還更差一些。因為這里需要使用兩個system call (select 和 recvfrom),而blocking IO只調用了一個system call (recvfrom)。但是,用select的優勢在于它可以同時處理多個connection。

所以,如果處理的連接數不是很高的話,使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好,可能延遲還更大。select/epoll的優勢并不是對于單個連接能處理得更快,而是在于能處理更多的連接。)

在IO multiplexing Model中,實際中,對于每一個socket,一般都設置成為non-blocking,但是,如上圖所示,整個用戶的process其實是一直被block的。只不過process是被select這個函數block,而不是被socket IO給block。

異步 I/O(asynchronous IO)

inux下的asynchronous IO其實用得很少。先看一下它的流程:
clipboard.png

用戶進程發起read操作之后,立刻就可以開始去做其它的事。而另一方面,從kernel的角度,當它受到一個asynchronous read之后,首先它會立刻返回,所以不會對用戶進程產生任何block。然后,kernel會等待數據準備完成,然后將數據拷貝到用戶內存,當這一切都完成之后,kernel會給用戶進程發送一個signal,告訴它read操作完成了。

總結

blocking和non-blocking的區別

調用blocking IO會一直block住對應的進程直到操作完成,而non-blocking IO在kernel還準備數據的情況下會立刻返回。

synchronous IO和asynchronous IO的區別

在說明synchronous IO和asynchronous IO的區別之前,需要先給出兩者的定義。POSIX的定義是這樣子的:
- A synchronous I/O operation causes the requesting process to be blocked until that I/O operation completes;
- An asynchronous I/O operation does not cause the requesting process to be blocked;

兩者的區別就在于synchronous IO做”IO operation”的時候會將process阻塞。按照這個定義,之前所述的blocking IO,non-blocking IO,IO multiplexing都屬于synchronous IO。

有人會說,non-blocking IO并沒有被block啊。這里有個非?!敖苹钡牡胤?,定義中所指的”IO operation”是指真實的IO操作,就是例子中的recvfrom這個system call。non-blocking IO在執行recvfrom這個system call的時候,如果kernel的數據沒有準備好,這時候不會block進程。但是,當kernel中數據準備好的時候,recvfrom會將數據從kernel拷貝到用戶內存中,這個時候進程是被block了,在這段時間內,進程是被block的。

而asynchronous IO則不一樣,當進程發起IO 操作之后,就直接返回再也不理睬了,直到kernel發送一個信號,告訴進程說IO完成。在這整個過程中,進程完全沒有被block。

各個IO Model的比較如圖所示:
clipboard.png

通過上面的圖片,可以發現non-blocking IO和asynchronous IO的區別還是很明顯的。在non-blocking IO中,雖然進程大部分時間都不會被block,但是它仍然要求進程去主動的check,并且當數據準備完成以后,也需要進程主動的再次調用recvfrom來將數據拷貝到用戶內存。而asynchronous IO則完全不同。它就像是用戶進程將整個IO操作交給了他人(kernel)完成,然后他人做完后發信號通知。在此期間,用戶進程不需要去檢查IO操作的狀態,也不需要主動的去拷貝數據。

三 I/O 多路復用之select、poll、epoll詳解

select,poll,epoll都是IO多路復用的機制。I/O多路復用就是通過一種機制,一個進程可以監視多個描述符,一旦某個描述符就緒(一般是讀就緒或者寫就緒),能夠通知程序進行相應的讀寫操作。但select,poll,epoll本質上都是同步I/O,因為他們都需要在讀寫事件就緒后自己負責進行讀寫,也就是說這個讀寫過程是阻塞的,而異步I/O則無需自己負責進行讀寫,異步I/O的實現會負責把數據從內核拷貝到用戶空間。(這里啰嗦下)

select

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

select 函數監視的文件描述符分3類,分別是writefds、readfds、和exceptfds。調用后select函數會阻塞,直到有描述副就緒(有數據 可讀、可寫、或者有except),或者超時(timeout指定等待時間,如果立即返回設為null即可),函數返回。當select函數返回后,可以 通過遍歷fdset,來找到就緒的描述符。

select目前幾乎在所有的平臺上支持,其良好跨平臺支持也是它的一個優點。select的一 個缺點在于單個進程能夠監視的文件描述符的數量存在最大限制,在Linux上一般為1024,可以通過修改宏定義甚至重新編譯內核的方式提升這一限制,但 是這樣也會造成效率的降低。

poll

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

不同與select使用三個位圖來表示三個fdset的方式,poll使用一個 pollfd的指針實現。

struct pollfd {
    int fd; /* file descriptor */
    short events; /* requested events to watch */
    short revents; /* returned events witnessed */
};

pollfd結構包含了要監視的event和發生的event,不再使用select“參數-值”傳遞的方式。同時,pollfd并沒有最大數量限制(但是數量過大后性能也是會下降)。 和select函數一樣,poll返回后,需要輪詢pollfd來獲取就緒的描述符。

從上面看,select和poll都需要在返回后,通過遍歷文件描述符來獲取已經就緒的socket。事實上,同時連接的大量客戶端在一時刻可能只有很少的處于就緒狀態,因此隨著監視的描述符數量的增長,其效率也會線性下降。

epoll

epoll是在2.6內核中提出的,是之前的select和poll的增強版本。相對于select和poll來說,epoll更加靈活,沒有描述符限制。epoll使用一個文件描述符管理多個描述符,將用戶關系的文件描述符的事件存放到內核的一個事件表中,這樣在用戶空間和內核空間的copy只需一次。

一 epoll操作過程

epoll操作過程需要三個接口,分別如下:

int epoll_create(int size);//創建一個epoll的句柄,size用來告訴內核這個監聽的數目一共有多大
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

1. int epoll_create(int size);
創建一個epoll的句柄,size用來告訴內核這個監聽的數目一共有多大,這個參數不同于select()中的第一個參數,給出最大監聽的fd+1的值,參數size并不是限制了epoll所能監聽的描述符最大個數,只是對內核初始分配內部數據結構的一個建議。
當創建好epoll句柄后,它就會占用一個fd值,在linux下如果查看/proc/進程id/fd/,是能夠看到這個fd的,所以在使用完epoll后,必須調用close()關閉,否則可能導致fd被耗盡。

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
函數是對指定描述符fd執行op操作。
- epfd:是epoll_create()的返回值。
- op:表示op操作,用三個宏來表示:添加EPOLL_CTL_ADD,刪除EPOLL_CTL_DEL,修改EPOLL_CTL_MOD。分別添加、刪除和修改對fd的監聽事件。
- fd:是需要監聽的fd(文件描述符)
- epoll_event:是告訴內核需要監聽什么事,struct epoll_event結構如下:

struct epoll_event {
  __uint32_t events;  /* Epoll events */
  epoll_data_t data;  /* User data variable */
};

//events可以是以下幾個宏的集合:
EPOLLIN :表示對應的文件描述符可以讀(包括對端SOCKET正常關閉);
EPOLLOUT:表示對應的文件描述符可以寫;
EPOLLPRI:表示對應的文件描述符有緊急的數據可讀(這里應該表示有帶外數據到來);
EPOLLERR:表示對應的文件描述符發生錯誤;
EPOLLHUP:表示對應的文件描述符被掛斷;
EPOLLET: 將EPOLL設為邊緣觸發(Edge Triggered)模式,這是相對于水平觸發(Level Triggered)來說的。
EPOLLONESHOT:只監聽一次事件,當監聽完這次事件之后,如果還需要繼續監聽這個socket的話,需要再次把這個socket加入到EPOLL隊列里

3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
等待epfd上的io事件,最多返回maxevents個事件。
參數events用來從內核得到事件的集合,maxevents告之內核這個events有多大,這個maxevents的值不能大于創建epoll_create()時的size,參數timeout是超時時間(毫秒,0會立即返回,-1將不確定,也有說法說是永久阻塞)。該函數返回需要處理的事件數目,如返回0表示已超時。

二 工作模式

 epoll對文件描述符的操作有兩種模式:LT(level trigger)ET(edge trigger)。LT模式是默認模式,LT模式與ET模式的區別如下:
  LT模式:當epoll_wait檢測到描述符事件發生并將此事件通知應用程序,應用程序可以不立即處理該事件。下次調用epoll_wait時,會再次響應應用程序并通知此事件。
  ET模式:當epoll_wait檢測到描述符事件發生并將此事件通知應用程序,應用程序必須立即處理該事件。如果不處理,下次調用epoll_wait時,不會再次響應應用程序并通知此事件。

1. LT模式

LT(level triggered)是缺省的工作方式,并且同時支持block和no-block socket.在這種做法中,內核告訴你一個文件描述符是否就緒了,然后你可以對這個就緒的fd進行IO操作。如果你不作任何操作,內核還是會繼續通知你的。

2. ET模式

ET(edge-triggered)是高速工作方式,只支持no-block socket。在這種模式下,當描述符從未就緒變為就緒時,內核通過epoll告訴你。然后它會假設你知道文件描述符已經就緒,并且不會再為那個文件描述符發送更多的就緒通知,直到你做了某些操作導致那個文件描述符不再為就緒狀態了(比如,你在發送,接收或者接收請求,或者發送接收的數據少于一定量時導致了一個EWOULDBLOCK 錯誤)。但是請注意,如果一直不對這個fd作IO操作(從而導致它再次變成未就緒),內核不會發送更多的通知(only once)

ET模式在很大程度上減少了epoll事件被重復觸發的次數,因此效率要比LT模式高。epoll工作在ET模式的時候,必須使用非阻塞套接口,以避免由于一個文件句柄的阻塞讀/阻塞寫操作把處理多個文件描述符的任務餓死。

3. 總結

假如有這樣一個例子:
1. 我們已經把一個用來從管道中讀取數據的文件句柄(RFD)添加到epoll描述符
2. 這個時候從管道的另一端被寫入了2KB的數據
3. 調用epoll_wait(2),并且它會返回RFD,說明它已經準備好讀取操作
4. 然后我們讀取了1KB的數據
5. 調用epoll_wait(2)......

LT模式:
如果是LT模式,那么在第5步調用epoll_wait(2)之后,仍然能受到通知。

ET模式:
如果我們在第1步將RFD添加到epoll描述符的時候使用了EPOLLET標志,那么在第5步調用epoll_wait(2)之后將有可能會掛起,因為剩余的數據還存在于文件的輸入緩沖區內,而且數據發出端還在等待一個針對已經發出數據的反饋信息。只有在監視的文件句柄上發生了某個事件的時候 ET 工作模式才會匯報事件。因此在第5步的時候,調用者可能會放棄等待仍在存在于文件輸入緩沖區內的剩余數據。

當使用epoll的ET模型來工作時,當產生了一個EPOLLIN事件后,
讀數據的時候需要考慮的是當recv()返回的大小如果等于請求的大小,那么很有可能是緩沖區還有數據未讀完,也意味著該次事件還沒有處理完,所以還需要再次讀?。?/p>

while(rs){
  buflen = recv(activeevents[i].data.fd, buf, sizeof(buf), 0);
  if(buflen < 0){
    // 由于是非阻塞的模式,所以當errno為EAGAIN時,表示當前緩沖區已無數據可讀
    // 在這里就當作是該次事件已處理處.
    if(errno == EAGAIN){
        break;
    }
    else{
        return;
    }
  }
  else if(buflen == 0){
     // 這里表示對端的socket已正常關閉.
  }

 if(buflen == sizeof(buf){
      rs = 1;   // 需要再次讀取
 }
 else{
      rs = 0;
 }
}

Linux中的EAGAIN含義

Linux環境下開發經常會碰到很多錯誤(設置errno),其中EAGAIN是其中比較常見的一個錯誤(比如用在非阻塞操作中)。
從字面上來看,是提示再試一次。這個錯誤經常出現在當應用程序進行一些非阻塞(non-blocking)操作(對文件或socket)的時候。

例如,以 O_NONBLOCK的標志打開文件/socket/FIFO,如果你連續做read操作而沒有數據可讀。此時程序不會阻塞起來等待數據準備就緒返回,read函數會返回一個錯誤EAGAIN,提示你的應用程序現在沒有數據可讀請稍后再試。
又例如,當一個系統調用(比如fork)因為沒有足夠的資源(比如虛擬內存)而執行失敗,返回EAGAIN提示其再調用一次(也許下次就能成功)。

三 代碼演示

下面是一段不完整的代碼且格式不對,意在表述上面的過程,去掉了一些模板代碼。

#define IPADDRESS   "127.0.0.1"
#define PORT        8787
#define MAXSIZE     1024
#define LISTENQ     5
#define FDSIZE      1000
#define EPOLLEVENTS 100

listenfd = socket_bind(IPADDRESS,PORT);

struct epoll_event events[EPOLLEVENTS];

//創建一個描述符
epollfd = epoll_create(FDSIZE);

//添加監聽描述符事件
add_event(epollfd,listenfd,EPOLLIN);

//循環等待
for ( ; ; ){
    //該函數返回已經準備好的描述符事件數目
    ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1);
    //處理接收到的連接
    handle_events(epollfd,events,ret,listenfd,buf);
}

//事件處理函數
static void handle_events(int epollfd,struct epoll_event *events,int num,int listenfd,char *buf)
{
     int i;
     int fd;
     //進行遍歷;這里只要遍歷已經準備好的io事件。num并不是當初epoll_create時的FDSIZE。
     for (i = 0;i < num;i++)
     {
         fd = events[i].data.fd;
        //根據描述符的類型和事件類型進行處理
         if ((fd == listenfd) &&(events[i].events & EPOLLIN))
            handle_accpet(epollfd,listenfd);
         else if (events[i].events & EPOLLIN)
            do_read(epollfd,fd,buf);
         else if (events[i].events & EPOLLOUT)
            do_write(epollfd,fd,buf);
     }
}

//添加事件
static void add_event(int epollfd,int fd,int state){
    struct epoll_event ev;
    ev.events = state;
    ev.data.fd = fd;
    epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&ev);
}

//處理接收到的連接
static void handle_accpet(int epollfd,int listenfd){
     int clifd;     
     struct sockaddr_in cliaddr;     
     socklen_t  cliaddrlen;     
     clifd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen);     
     if (clifd == -1)         
     perror("accpet error:");     
     else {         
         printf("accept a new client: %s:%d\n",inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);                       //添加一個客戶描述符和事件         
         add_event(epollfd,clifd,EPOLLIN);     
     } 
}

//讀處理
static void do_read(int epollfd,int fd,char *buf){
    int nread;
    nread = read(fd,buf,MAXSIZE);
    if (nread == -1)     {         
        perror("read error:");         
        close(fd); //記住close fd        
        delete_event(epollfd,fd,EPOLLIN); //刪除監聽 
    }
    else if (nread == 0)     {         
        fprintf(stderr,"client close.\n");
        close(fd); //記住close fd       
        delete_event(epollfd,fd,EPOLLIN); //刪除監聽 
    }     
    else {         
        printf("read message is : %s",buf);        
        //修改描述符對應的事件,由讀改為寫         
        modify_event(epollfd,fd,EPOLLOUT);     
    } 
}

//寫處理
static void do_write(int epollfd,int fd,char *buf) {     
    int nwrite;     
    nwrite = write(fd,buf,strlen(buf));     
    if (nwrite == -1){         
        perror("write error:");        
        close(fd);   //記住close fd       
        delete_event(epollfd,fd,EPOLLOUT);  //刪除監聽    
    }else{
        modify_event(epollfd,fd,EPOLLIN); 
    }    
    memset(buf,0,MAXSIZE); 
}

//刪除事件
static void delete_event(int epollfd,int fd,int state) {
    struct epoll_event ev;
    ev.events = state;
    ev.data.fd = fd;
    epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,&ev);
}

//修改事件
static void modify_event(int epollfd,int fd,int state){     
    struct epoll_event ev;
    ev.events = state;
    ev.data.fd = fd;
    epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&ev);
}

//注:另外一端我就省了

四 epoll總結

在 select/poll中,進程只有在調用一定的方法后,內核才對所有監視的文件描述符進行掃描,而epoll事先通過epoll_ctl()來注冊一 個文件描述符,一旦基于某個文件描述符就緒時,內核會采用類似callback的回調機制,迅速激活這個文件描述符,當進程調用epoll_wait() 時便得到通知。(此處去掉了遍歷文件描述符,而是通過監聽回調的的機制。這正是epoll的魅力所在。)

epoll的優點主要是一下幾個方面:
1. 監視的描述符數量不受限制,它所支持的FD上限是最大可以打開文件的數目,這個數字一般遠大于2048,舉個例子,在1GB內存的機器上大約是10萬左 右,具體數目可以cat /proc/sys/fs/file-max察看,一般來說這個數目和系統內存關系很大。select的最大缺點就是進程打開的fd是有數量限制的。這對 于連接數量比較大的服務器來說根本不能滿足。雖然也可以選擇多進程的解決方案( Apache就是這樣實現的),不過雖然linux上面創建進程的代價比較小,但仍舊是不可忽視的,加上進程間數據同步遠比不上線程間同步的高效,所以也不是一種完美的方案。

  1. IO的效率不會隨著監視fd的數量的增長而下降。epoll不同于select和poll輪詢的方式,而是通過每個fd定義的回調函數來實現的。只有就緒的fd才會執行回調函數。

如果沒有大量的idle -connection或者dead-connection,epoll的效率并不會比select/poll高很多,但是當遇到大量的idle- connection,就會發現epoll的效率大大高于select/poll。

參考

用戶空間與內核空間,進程上下文與中斷上下文[總結]
進程切換
維基百科-文件描述符
Linux 中直接 I/O 機制的介紹
IO - 同步,異步,阻塞,非阻塞 (亡羊補牢篇)
Linux中select poll和epoll的區別
IO多路復用之select總結
IO多路復用之poll總結
IO多路復用之epoll總結

查看原文

贊 610 收藏 1060 評論 64

薯條 關注了用戶 · 2月19日

波波Nadia @bobonadia

SegmentFault COO & 思否編程聯席 CEO
思否技術人訪談專欄作者,尋求報道、個人/廠商投稿、提供線索: nadia@sifou.com

關注 104

薯條 關注了用戶 · 2月19日

kumfo @kumfo

程序生存法則:?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
1.不要寫死
2.不要相信產品?≧??≦?
設計生存法則:
1.不要相信這是最終效果圖
2.不要相信產品

測試生存法則:
1.不要立flag
2.不要相信程序
產品生存法則:
1.不要相信任何人
2.注意人身安全
運營生存法則:
1.不要相信任何人
2.躲在產品身后

關注 2073

薯條 關注了用戶 · 2月19日

高陽Sunny @sunny

SegmentFault 思否 CEO
C14Z.Group Founder
Forbes China 30U30

獨立思考 敢于否定

曾經是個話癆... 要做一個有趣的人!

任何問題可以給我發私信或者發郵件 sunny@sifou.com

關注 2162

薯條 發布了文章 · 2月19日

如何提高代碼的可讀性 學習筆記

本文整理自 taowen 師傅在滴滴內部的分享。

1.Why

對一線開發人員來說,每天工作內容大多是在已有項目的基礎上繼續堆代碼。當項目實在堆不動時就需要尋找收益來重構代碼。既然我們的大多數時間都花在坐在顯示器前讀寫代碼這件事上,那可讀性不好的代碼都是在謀殺自己or同事的生命,所以不如一開始就提煉技巧,努力寫好代碼; )

2.How

為提高代碼可讀性,先來分析代碼實際運行環境。代碼實際運行于兩個地方:cpu人腦。對于cpu,代碼優化需理解其工作機制,寫代碼時為針對cpu特性進行優化;對于人腦,我們在讀代碼時,它像解釋器一樣,一行一行運行代碼,從這個角度來說,要提高代碼的可讀性首先需要知道大腦的運行機制。

image.png

下面來看一下人腦適合做的事情和不適合做的事情:

大腦擅長做的事情

名稱圖片說明
對象識別image.png不同于機器學習看無數張貓片之后可能還是不能準確識別貓這個對象,人腦在看過幾只貓之后就可以很好的識別。
空間分解image.png人腦不需要標注,可以直觀感受到空間中的不同物體。
時序預測image.png你的第一感覺是不是這個哥們要被車撞了?
時序記憶image.png作為人類生存本能之一,我們多次走過某個地方時,人腦會對這個地方形成記憶。
類比推測image.png人腦還有類比功能,比如說這道題大多數人會選擇C吧。

大腦不擅長做的事情

名稱圖片例子
無法映射到現實生活經驗的抽象概念image.png人腦看到左圖時,會比較輕松想到通關方式,但是如果換成右圖這種抽象的概念,里面的對象換成了嘿嘿的像素,我們就不知道這是什么鬼了。比如說代碼里如果充斥著Z,X,C,V 這樣的變量名,你可能就看懵了。
冗長的偵探推理image.png這種需要遞歸(or循環)去檢查所有可能性最后找到解法的場景,人腦同樣不擅長。
跟蹤多個同時變化的過程image.png大腦是個單線程的CPU,不擅長左手畫圓,右手畫圈。

代碼優化理論

了解人腦的優缺點后,寫代碼時就可以根據人腦的特點對應改善代碼的可讀性了。這里提取出三種理論:

  1. Align Models ,匹配模型:代碼中的數據和算法模型 應和人腦中的 心智模型對應
  2. Shorten Process , 簡短處理:寫代碼時應 縮短 “福爾摩斯探案集” 的流程長度,即不要寫大段代碼
  3. Isolate Process,隔離處理:寫代碼一個流程一個流程來處理,不要同時描述多個流程的演進過程

下面通過例子詳細解釋這三種模型:

Align Models

在代碼中,模型無外乎就是數據結構算法,而在人腦中,對應的是心智模型,所謂心智模型就是人腦對于一個物體 or 一件事情的想法,我們平時說話就是心智模型的外在表現。寫代碼時應把代碼中的名詞與現實名詞對應起來,減少人腦從需求文檔到代碼的映射成本。比如對于“銀行賬戶”這個名詞,很多變量名都可以體現這個詞,比如:bankAccount、bank_account、account、BankAccount、BA、bank_acc、item、row、record、model,編碼中應統一使用和現實對象能鏈接上的變量名。

代碼命名技巧

起變量名時候取其實際含義,沒必要隨便寫個變量名然后在注釋里面偷偷用功。

// bad
var d int // elapsed time in days

// good
var elapsedTimeInDays int // 全局使用

起函數名 動詞+名詞結合,還要注意標識出你的自定義變量類型:

// bad
func getThem(theList [][]int) [][]int {
    var list1 [][]int // list1是啥,不知道
    for _, x := range theList {
        if x[0] == 4 { // 4是啥,不知道
            list1 = append(list1, x)
        }
    }
    return list1
}

// good
type Cell []int // 標識[]int作用

func (cell Cell) isFlagged() bool { // 說明4的作用
    return cell[0] == 4
}

func getFlaggedCells(gameBoard []Cell) []Cell { // 起有意義的變量名
    var flaggedCells []Cell
    for _, cell := range gameBoard {
        if cell.isFlagged() {
            flaggedCells = append(flaggedCells, cell)
        }
    }
    return flaggedCells
}
代碼分解技巧

按照空間分解(Spatial Decomposition):下面這塊代碼都是與Page相關的邏輯,仔細觀察可以根據page的空間分解代碼:

// bad
// …then…and then … and then ... // 平鋪直敘描述整個過程
func RenderPage(request *http.Request) map[string]interface{} {
    page := map[string]interface{}{}
    name := request.Form.Get("name")
    page["name"] = name
    urlPathName := strings.ToLower(name)
    urlPathName = regexp.MustCompile(`['.]`).ReplaceAllString(
        urlPathName, "")
    urlPathName = regexp.MustCompile(`[^a-z0-9]+`).ReplaceAllString(
        urlPathName, "-")
    urlPathName = strings.Trim(urlPathName, "-")
    page["url"] = "/biz/" + urlPathName
    page["date_created"] = time.Now().In(time.UTC)
    return page
}
// good
// 按空間分解,這樣的好處是可以集中精力到關注的功能上
var page = map[string]pageItem{
    "name":         pageName,
    "url":          pageUrl,
    "date_created": pageDateCreated,
}

type pageItem func(*http.Request) interface{}

func pageName(request *http.Request) interface{} { // name 相關過程
    return request.Form.Get("name")
}

func pageUrl(request *http.Request) interface{} { // URL 相關過程
    name := request.Form.Get("name")
    urlPathName := strings.ToLower(name)
    urlPathName = regexp.MustCompile(`['.]`).ReplaceAllString(
        urlPathName, "")
    urlPathName = regexp.MustCompile(`[^a-z0-9]+`).ReplaceAllString(
        urlPathName, "-")
    urlPathName = strings.Trim(urlPathName, "-")
    return "/biz/" + urlPathName
}

func pageDateCreated(request *http.Request) interface{} { // Date 相關過程
    return time.Now().In(time.UTC)
}

按照時間分解(Temporal Decomposition):下面這塊代碼把整個流程的算賬和打印賬單混寫在一起,可以按照時間順序對齊進行分解:

// bad 
func (customer *Customer) statement() string {
    totalAmount := float64(0)
    frequentRenterPoints := 0
    result := "Rental Record for " + customer.Name + "\n"

    for _, rental := range customer.rentals {
        thisAmount := float64(0)
        switch rental.PriceCode {
        case REGULAR:
            thisAmount += 2
        case New_RELEASE:
            thisAmount += rental.rent * 2
        case CHILDREN:
            thisAmount += 1.5
        }
        frequentRenterPoints += 1
        totalAmount += thisAmount
    }
    result += strconv.FormatFloat(totalAmount,'g',10,64) + "\n"
    result += strconv.Itoa(frequentRenterPoints)

    return result
}
// good 邏輯分解后的代碼
func statement(custom *Customer) string {
    bill := calcBill(custom)

    statement := bill.print()

    return statement
}

type RentalBill struct {
    rental Rental
    amount float64
}

type Bill struct {
    customer             *Customer
    rentals              []RentalBill
    totalAmount          float64
    frequentRenterPoints int
}

func calcBill(customer *Customer) Bill {

    bill := Bill{}
    for _, rental := range customer.rentals {
        rentalBill := RentalBill{
            rental: rental,
            amount: calcAmount(rental),
        }
        bill.frequentRenterPoints += calcFrequentRenterPoints(rental)
        bill.totalAmount += rentalBill.amount
        bill.rentals = append(bill.rentals, rentalBill)
    }
    return bill
}

func (bill Bill) print() string {

    result := "Rental Record for " + bill.customer.name + "(n"

    for _, rental := range bill.rentals{
        result += "\t" + rental.movie.title + "\t" +
            strconv.FormatFloat(rental.amount, 'g', 10, 64) + "\n"
    }
    

    result += "Amount owed is " +
        strconv.FormatFloat(bill.totalAmount, 'g', 10, 64) + "\n"

    result += "You earned + " +
        strconv.Itoa(bill.frequentRenterPoints) + "frequent renter points"

    return result
}

func calcAmount(rental Rental) float64 {
    thisAmount := float64(0)
    switch rental.movie.priceCode {
    case REGULAR:
        thisAmount += 2
        if rental.daysRented > 2 {
            thisAmount += (float64(rental.daysRented) - 2) * 1.5
        }
    case NEW_RELEASE:
        thisAmount += float64(rental.daysRented) * 3
    case CHILDRENS:
        thisAmount += 1.5
        if rental.daysRented > 3 {
            thisAmount += (float64(rental.daysRented) - 3) * 1.5
        }
    }
    return thisAmount
}

func calcFrequentRenterPoints(rental Rental) int {
    frequentRenterPoints := 1
    switch rental.movie.priceCode {
    case NEW_RELEASE:
        if rental.daysRented > 1 {
            frequentRenterPointst++
        }
    }
    return frequentRenterPoints
}

按層分解(Layer Decomposition):

// bad
func findSphericalClosest(lat float64, lng float64, locations []Location) *Location {
    var closest *Location
  closestDistance := math.MaxFloat64
  for _, location := range locations {
    latRad := radians(lat)
    lngRad := radians(lng)
    lng2Rad := radians(location.Lat)
    lng2Rad := radians(location.Lng)
    var dist = math.Acos(math.Sin(latRad) * math.Sin(lat2Rad) +  
                         math.Cos(latRad) * math.Cos(lat2Rad) *
                         math.Cos(lng2Rad - lngRad) 
                        )
    if dist < closestDistance {
            closest = &location
      closestDistance = dist
    }
  }
    return closet
}
// good
type Location struct {
}

type compare func(left Location, right Location) int

func min(objects []Location, compare compare) *Location {
    var min *Location
    for _, object := range objects {
        if min == nil {
            min = &object
            continue
        }
        if compare(object, *min) < 0 {
            min = &object
        }
    }
    return min
}

func findSphericalClosest(lat float64, lng float64, locations []Location) *Location {
    isCloser := func(left Location, right Location) int {
        leftDistance := rand.Int()
        rightDistance := rand.Int()
        if leftDistance < rightDistance {
            return -1
        } else {
            return 0
        }
    }
    closet := min(locations, isCloser)
    return closet
}
注釋

注釋不應重復代碼的工作。應該去解釋代碼的模型和心智模型的映射關系,應說明為什么要使用這個代碼模型,下面的例子就是反面教材:

// bad
/** the name. */
var name string
/** the version. */
var Version string
/** the info. */
var info string

// Find the Node in the given subtree, with the given name, using the given depth.
func FindNodeInSubtree(subTree *Node, name string, depth *int) *Node {
}

下面的例子是正面教材:

// Impose a reasonable limit - no human can read that much anyway
const MAX_RSS_SUBSCRIPTIONS = 1000

// Runtime is O(number_tags * average_tag_depth), 
// so watch out for badly nested inputs.
func FixBrokenHTML(HTML string) string {
    // ...
}

Shorten Process

Shorten Process的意思是要縮短人腦“編譯代碼”的流程。應該避免寫出像小白鼠走迷路一樣又長又繞的代碼。所謂又長又繞的代碼表現在,跨表達式跟蹤、跨多行函數跟蹤、跨多個成員函數跟蹤、跨多個文件跟蹤、跨多個編譯單元跟蹤,甚至是跨多個代碼倉庫跟蹤。

對應的手段可以有:引入變量、拆分函數、提早返回、縮小變量作用域,這些方法最終想達到的目的都是讓大腦喘口氣,不要一口氣跟蹤太久。同樣來看一些具體的例子:

例子

下面的代碼,多種復合條件組合在一起,你看了半天繞暈了可能也沒看出到底什么情況下為true,什么情況為false。

// bad
func (rng *Range) overlapsWith(other *Range) bool {
    return (rng.begin >= other.begin && rng.begin < other.end) ||
        (rng.end > other.begin && rng.end <= other.end) ||
        (rng.begin <= other.begin && rng.end >= other.end)
}

但是把情況進行拆解,每種條件進行單獨處理。這樣邏輯就很清晰了。

// good
func (rng *Range) overlapsWith(other *Range) bool {
    if other.end < rng.begin {
        return false // they end before we begin 
    }    
    if other.begin >= rng.end {
        return false // they begin after we end 
    }
  return true // Only possibility left: they overlap
}

再來看一個例子,一開始你寫代碼的時候,可能只有一個if ... else...,后來PM讓加一下權限控制,于是你可以開心的在if里繼續套一層if,補丁打完,開心收工,于是代碼看起來像這樣:

// bad 多層縮進的問題
func handleResult(reply *Reply, userResult int, permissionResult int) {
  if userResult == SUCCESS {
    if permissionResult != SUCCESS {
      reply.WriteErrors("error reading permissions")
        reply.Done()
        return
    }
    reply.WriteErrors("")
  } else {
    reply.WriteErrors("User Result")
  }
  reply.Done()
}

這種代碼也比較好改,一般反向寫if條件返回判否邏輯即可:

// good
func handleResult(reply *Reply, userResult int, permissionResult int) {
  defer reply.Done()
  if userResult != SUCCESS {
    reply.WriteErrors("User Result")
    return 
  }
  if permissionResult != SUCCESS {
    reply.WriteErrors("error reading permissions")
    return
  }
  reply.WriteErrors("")
}

這個例子的代碼問題比較隱晦,它的問題是所有內容都放在了MooDriver這個對象中。

// bad
type MooDriver struct {
    gradient Gradient
  splines []Spline
}
func (driver *MooDriver) drive(reason string) {
  driver.saturateGradient()
  driver.reticulateSplines()
  driver.diveForMoog(reason)
}

比較好的方法是盡可能減少全局scope,而是使用上下文變量進行傳遞。

// good 
type ExplicitDriver struct {
  
}

// 使用上下文傳遞
func (driver *MooDriver) drive(reason string) {
  gradient := driver.saturateGradient()
  splines := driver.reticulateSplines(gradient)
  driver.diveForMoog(splines, reason)
}

Isolate Process

人腦缺陷是不擅長同時跟蹤多件事情,如果”同時跟蹤“事物的多個變化過程,這不符合人腦的構造;但是如果把邏輯放在很多地方,這對大腦也不友好,因為大腦需要”東拼西湊“才能把一塊邏輯看全。所以就有了一句很經典的廢話,每個學計算機的大學生都聽過。你的代碼要做到高內聚,低耦合,這樣就牛逼了!-_-|||,但是你要問說這話的人什么叫高內聚,低耦合呢,他可能就得琢磨琢磨了,下面來通過一些例子來琢磨一下。

首先先來玄學部分,如果你的代碼寫成下面這樣,可讀性就不會很高。

image.png

一般情況下,我們可以根據業務場景努力把代碼修改成這樣:

image.png

舉幾個例子,下面這段代碼非常常見,里面version的含義是用戶端上不同的版本需要做不同的邏輯處理。

func (query *Query) doQuery() {
  if query.sdQuery != nil {
    query.sdQuery.clearResultSet()
  }
  // version 5.2 control
  if query.sd52 {
    query.sdQuery = sdLoginSession.createQuery(SDQuery.OPEN_FOR_QUERY)
  } else {
    query.sdQuery = sdSession.createQuery(SDQuery.OPEN_FOR_QUERY)
  }
  query.executeQuery()
}

這段代碼的問題是由于版本差異多塊代碼流程邏輯Merge在了一起,造成邏輯中間有分叉現象。處理起來也很簡單,封裝一個adapter,把版本邏輯抽出一個interface,然后根據版本實現具體的邏輯。

再來看個例子,下面代碼中根據expiry和maturity這樣的產品邏輯不同 也會造成分叉現象,所以你的代碼會寫成這樣:

// bad
type Loan struct {
    start    time.Time
    expiry   *time.Time
    maturity *time.Time
    rating   int
}

func (loan *Loan) duration() float64 {
    if loan.expiry == nil {
        return float64(loan.maturity.Unix()-loan.start.Unix()) / 365 * 24 * float64(time.Hour)
    } else if loan.maturity == nil {
        return float64(loan.expiry.Unix()-loan.start.Unix()) / 365 * 24 * float64(time.Hour)
    }
    toExpiry := float64(loan.expiry.Unix() - loan.start.Unix())
    fromExpiryToMaturity := float64(loan.maturity.Unix() - loan.expiry.Unix())
    revolverDuration := toExpiry / 365 * 24 * float64(time.Hour)
    termDuration := fromExpiryToMaturity / 365 * 24 * float64(time.Hour)
    return revolverDuration + termDuration
}

func (loan *Loan) unusedPercentage() float64 {
    if loan.expiry != nil && loan.maturity != nil {
        if loan.rating > 4 {
            return 0.95
        } else {
            return 0.50
        }
    } else if loan.maturity != nil {
        return 1
    } else if loan.expiry != nil {
        if loan.rating > 4 {
            return 0.75
        } else {
            return 0.25
        }
    }
    panic("invalid loan")
}

解決多種產品邏輯的最佳實踐是Strategy pattern,代碼入下圖,根據產品類型創建出不同的策略接口,然后分別實現duration和unusedPercentage這兩個方法即可。

// good
type LoanApplication struct {
    expiry   *time.Time
    maturity *time.Time
}

type CapitalStrategy interface {
    duration() float64
    unusedPercentage() float64
}

func createLoanStrategy(loanApplication LoanApplication) CapitalStrategy {
    if loanApplication.expiry != nil && loanApplication.maturity != nil {
        return createRCTL(loanApplication)
    }
    if loanApplication.expiry != nil {
        return createRevolver(loanApplication)
    }
    if loanApplication.maturity != nil {
        return createTermLoan
    }
    panic("invalid loan application")
}

但是現實情況沒有這么簡單,因為不同事物在你眼中就是多進程多線程運行的,比如上面產品邏輯的例子,雖然通過一些設計模式把執行的邏輯隔離到了不同地方,但是代碼中只要含有多種產品,代碼在執行時還是會有一個產品選擇的過程。邏輯發生在同一時間、同一空間,所以“自然而然”就需要寫在了一起:

  • 功能展示時,由于需要展示多種信息,會造成 concurrent process
  • 寫代碼時,業務包括功能性和非功能性需求,也包括正常邏輯和異常邏輯處理
  • 考慮運行效率時,為提高效率我們會考慮異步I/O、多線程/協程
  • 考慮流程復用時,由于版本差異和產品策略也會造成merged concurrent process

對于多種功能雜糅在一起,比如上面的RenderPage函數,對應解法為不要把所有事情合在一起搞,把單塊功能內聚,整體再耦合成為一個單元。

對于多個同步進行的I/O操作,可以通過協程把揉在一起的過程分開來:

// bad 兩個I/O寫到一起了
func sendToPlatforms() {
    httpSend("bloomberg", func(err error) {
        if err == nil {
            increaseCounter("bloomberg_sent", func(err error) {
                if err != nil {
                    log("failed to record counter", err)
                }
            })
        } else {
            log("failed to send to bloom berg", err)
        }
    })
    ftpSend("reuters", func(err error) {
        if err == DIRECTORY_NOT_FOUND {
            httpSend("reuterHelp", err)
        }
    })
}

對于這種并發的I/O場景,最佳解法就是給每個功能各自寫一個計算函數,代碼真正運行的時候是”同時“在運行,但是代碼中是分開的。

//good 協程寫法
func sendToPlatforms() {
    go sendToBloomberg()
    go sendToReuters()
}

func sendToBloomberg() {
    err := httpSend("bloomberg")
    if err != nil {
        log("failed to send to bloom berg", err)
        return
    }
    err := increaseCounter("bloomberg_sent")
    if err != nil {
        log("failed to record counter", err)
    }
}

func sendToReuters() {
    err := ftpSend("reuters")
    if err == nil {
        httpSend("reutersHelp", err)
    }
}

有時,邏輯必須要合并到一個Process里面,比如在買賣商品時必須要對參數做邏輯檢查:

// bad
func buyProduct(req *http.Request) error {
    err := checkAuth(req)
    if err != nil {
        return err
    }
    // ...
}

func sellProduct(req *http.Request) error {
    err := checkAuth(req)
    if err != nil {
        return err
    }
    // ...
}

這種頭部有公共邏輯經典解法是寫個Decorator單獨處理權限校驗邏輯,然后wrapper一下正式邏輯即可:

// good 裝飾器寫法
func init() {
    buyProduct = checkAuthDecorator(buyProduct)
    sellProduct = checkAuthDecorator(sellProduct)
}

func checkAuthDecorator(f func(req *http.Request) error) func(req *http.Request) error {
    return func(req *http.Request) error {
        err := checkAuth(req)
        if err != nil {
            return err
        }
        return f(req)
    }
}

var buyProduct = func(req *http.Request) error {
    // ...
}

var sellProduct = func(req *http.Request) error {
    // ...
}

此時你的代碼會想這樣:

image.png

當然公共邏輯不僅僅存在于頭部,仔細思考一下所謂的strategy、Template pattern,他們是在邏輯的其他地方去做這樣的邏輯處理。

image.png

這塊有一個新的概念叫:信噪比。信噪比是一個相對概念,信息,對有用的;噪音,對沒用的。代碼應把什么邏輯寫在一起,不僅取決于讀者是誰,還取決于這個讀者當時希望完成什么目標。

比如下面這段C++和Python代碼:

void sendMessage(const Message &msg) const {...}
![image.png](/img/bVcOMhy)
def sendMessage(msg):

如果你現在要做業務開發,你可能會覺得Python代碼讀起來很簡潔;但是如果你現在要做一些性能優化的工作,C++代碼顯然能給你帶來更多信息。

再比如下面這段代碼,從業務邏輯上講,這段開發看起來非常清晰,就是去遍歷書本獲取Publisher。

for _, book := range books {
  book.getPublisher()
}

但是如果你看了線上打了如下的SQL日志,你懵逼了,心想這個OOM真**,真就是一行一行執行SQL,這行代碼可能會引起DB報警,讓你的DBA同事半夜起來修DB。

SELECT * FROM Pubisher WHERE PublisherId = book.publisher_id
SELECT * FROM Pubisher WHERE PublisherId = book.publisher_id
SELECT * FROM Pubisher WHERE PublisherId = book.publisher_id
SELECT * FROM Pubisher WHERE PublisherId = book.publisher_id
SELECT * FROM Pubisher WHERE PublisherId = book.publisher_id

所以如果代碼改成這樣,你可能就會更加明白這塊代碼其實是在循環調用實體。

for _, book := range books {
  loadEntity("publisher", book.publisher_id)
}

總結一下:

  • 優先嘗試給每 個Process一個自己的函數,不要合并到一起來算

    • 嘗試界面拆成組件
    • 嘗試把訂單拆成多個單據,獨立跟蹤多個流程
    • 嘗試用協程而不是回調來表達concurrent i/o
  • 如果不得不在一個Process中處理多個相對獨立的事情

    • 嘗試復制一份代碼,而不是復用同一個Process
    • 嘗試顯式插入: state/ adapter/ strategy/template/ visitor/ observer
    • 嘗試隱式插入: decorator/aop
    • 提高信噪比是相對于具體目標的,提高了一個目標的信噪比,就降低了另外一個目標的信噪比

3.總結

當我們吐槽這塊代碼可讀性太差時,不要把可讀性差的原因簡單歸結為注釋不夠 或者不OO,而是可以從人腦特性出發,根據下面的圖片去找到代碼問題,然后試著改進它(跑了幾年的老代碼還是算了,別改一行線上全炸了: )

image.png

查看原文

贊 22 收藏 5 評論 0

薯條 關注了用戶 · 2月18日

xiangzhihong @xiangzhihong

著有《React Native移動開發實戰》1,2、《Kotlin入門與實戰》《Weex跨平臺開發實戰》、《Flutter跨平臺開發與實戰》和《Android應用開發實戰》

關注 8346

薯條 關注了專欄 · 2月18日

阿里云棲號

匯集阿里技術精粹-yq.aliyun.com

關注 15771

薯條 關注了專欄 · 2月18日

SegmentFault 行業快訊

第一時間為開發者提供行業相關的實時熱點資訊

關注 58560

薯條 關注了專欄 · 2月18日

終身學習者

我要先堅持分享20年,大家來一起見證吧。

關注 51646

薯條 關注了專欄 · 2月18日

隨筆

希望可以記錄下我的成長之旅,也希望可以幫助大家

關注 1102

認證與成就

  • 獲得 22 次點贊
  • 獲得 0 枚徽章 獲得 0 枚金徽章, 獲得 0 枚銀徽章, 獲得 0 枚銅徽章

擅長技能
編輯

開源項目 & 著作
編輯

(??? )
暫時沒有

注冊于 2020-12-14
個人主頁被 1.1k 人瀏覽

一本到在线是免费观看_亚洲2020天天堂在线观看_国产欧美亚洲精品第一页_最好看的2018中文字幕 <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <蜘蛛词>| <文本链> <文本链> <文本链> <文本链> <文本链> <文本链>