❶ php FPM源代碼反芻品味之四：事件處理
FPM master 進程啟動後，會進入函數fpm_event_loop,無限循環.
處理事件.
master 進程所做的的事，總的來說就是兩類：
簡稱timer事件,需按時運行，主要有3個:
簡稱fd事件,需從文件句柄(file descriptor)讀取到指令後，依指令運行．
重復一下，unix 下一切IO, 皆文件，socket ,socketpair,pipe 都返迴文件句柄(fd) 用於通信．
主要的fd有:
對於timer事件，多個事件在事件軸上是依次排列的，只需反復檢查，到時運行．
對於fd事件，需監聽多個fd，需用到我們第二篇講的IO多路復用技術．
如果滿足事件條件，則處理事件內容．
FPM設計上，兩類事件使用同一個結構，並且事件觸發條件和事件處理邏輯放到同一個事件對象里(C語言對象就是結構體)．
舉個例子， 打鈴下課，打鈴是觸發條件，下課是事件內容，兩個同時放到一個事件對象 ，這是一個很好的設計．
fd值: -1
flags值:FPM_EV_PERSIST
which值: FPM_EV_TIMEOUT
fd值: 獲取觸發指令的文件fd
flags值: FPM_EV_EDGE(fd事件底層的邊緣觸發標志,需系統支持)
which值: FPM_EV_READ
兩類事件分別放在兩個事件隊列
static struct fpm_event_queue_s *fpm_event_queue_timer = NULL;
static struct fpm_event_queue_s *fpm_event_queue_fd = NULL;
事件隊列的結構很常見，雙向隊列：
typedef struct fpm_event_queue_s {
struct fpm_event_queue_s *prev;
struct fpm_event_queue_s *next;
struct fpm_event_s *ev;
} fpm_event_queue;
4移除事件 (fpm_event_del -> fpm_event_queue_del)
簡單的出列操作：
static int fpm_event_queue_del(struct fpm_event_queue_s **queue, struct fpm_event_s *ev)
對於fd事件,需在底層事件輪詢機制里移除（如：epoll）
5,運行事件回調函數：
6, 底層事件輪詢模塊結構
不同的操作系統，支持不同的IO事件機制，linux 支持epoll,
windows支持select, freebsd 支持kqueue,這個結構統一操作介面
在函數fpm_event_init_main里 調用mole->init初始化
fpm 里對應的配置
master進程在fpm_event_loop函數里無限循環，處理定時任務和fd事件.
期間會在mole->wait阻塞片刻，對於epoll機制，就是epoll_wait．
❷ php新手學習路線是怎樣的
第一階段：基礎階段（基礎PHP程序員）
重點：把LNMP搞熟練（核心是安裝配置基本操作） 目標：能夠完成基本的LNMP系統安裝，簡單配置維護；能夠做基本的簡單系統的PHP開發；能夠在PHP中型系統中支持某個PHP功能模塊的開發。
時間：完成本階段的時間因人而異，有的成長快半年一年就過了，成長慢的兩三年也有。
Linux
基本命令、操作、啟動、基本服務配置（包括rpm安裝文件，各種服務配置等）；會寫簡單的shell腳本和awk/sed 腳本命令等。
Nginx
做到能夠安裝配置nginx+php，知道基本的nginx核心配置選項，知道 server/fastcgi_pass/access_log 等基礎配置，目標是能夠讓nginx+php_fpm順利工作。
MySQL
會自己搭建mysql，知道基本的mysql配置選項；知道innodb和myisam的區別，知道針對InnoDB和MyISAM兩個引擎的不同配置選項；知道基本的兩個引擎的差異和選擇上面的區別；能夠純手工編譯搭建一個MySQL資料庫並且配置好編碼等正常穩定運行；核心主旨是能夠搭建一個可運行的MySQL資料庫。
PHP
基本語法數組、字元串、資料庫、XML、Socket、GD/ImageMgk圖片處理等等；熟悉各種跟MySQL操作鏈接的api（mysql/mysqli/PDO)，知道各種編碼問題的解決；知道常規熟練使用的PHP框架（ThinkPHP、Zendframework、Yii、Yaf等）；了解基本MVC的運行機制和為什麼這么做，稍微知道不同的PHP框架之間的區別；能夠快速學習一個MVC框架。能夠知道開發工程中的文件目錄組織，有基本的良好的代碼結構和風格，能夠完成小系統的開發和中型系統中某個模塊的開發工作。
前端
如果條件時間允許，可以適當學習下 HTML/CSS/JS 等相關知識，知道什麼web標准，div+css的web/wap頁面模式，知道HTML5和HTML4的區別；了解一些基本的前端只是和JS框架（jQuery之類的）；了解一些基本的JavaScript編程知識；（本項不是必須項，如果有時間，稍微了解一下是可以的，不過不建議作為重點，除非個人有強烈興趣）。
系統設計
能夠完成小型系統的基本設計，包括簡單的資料庫設計，能夠完成基本的：瀏覽器 -> Nginx+PHP -> 資料庫 架構的設計開發工作；能夠支撐每天幾十萬到數百萬流量網站的開發維護工作；
第二階段：提高階段 （中級PHP程序員）
重點：提高針對LNMP的技能，能夠更全面的對LNMP有熟練的應用。 目標：能夠隨時隨地搭建好LNMP環境，快速完成常規配置；能夠追查解決大部分遇到的開發和線上環境的問題；能夠獨立承擔中型系統的構架和開發工作；能夠在大型系統中承擔某個中型模塊的開發工作。
1. Linux
在第一階段的基礎上面，能夠流暢的使用Shell腳本來完成很多自動化的工作；awk/sed/perl 也操作的不錯，能夠完成很多文本處理和數據統計等工作；基本能夠安裝大部分非特殊的Linux程序（包括各種庫、包、第三方依賴等等，比如MongoDB/Redis/Sphinx/Luncene/SVN之類的）；了解基本的Linux服務，知道如何查看Linux的性能指標數據，知道基本的Linux下面的問題跟蹤等。
2. Nginx
在第一階段的基礎上面，了解復雜一些的Nginx配置；包括 多核配置、events、proxy_pass，sendfile/tcp_*配置，知道超時等相關配置和性能影響；知道nginx除了web server，還能夠承擔代理伺服器、反向靜態伺服器等配置；知道基本的nginx配置調優；知道如何配置許可權、編譯一個nginx擴展到nginx；知道基本的nginx運行原理（master/worker機制，epoll），知道為什麼nginx性能比apache性能好等知識。
3. MySQL/MongoDB
在第一階段的基礎上面，在MySQL開發方面，掌握很多小技巧，包括常規SQL優化（group by/order by/rand優化等）；除了能夠搭建MySQL，還能夠冷熱備份MySQL數據，還知道影響innodb/myisam性能的配置選項（比如key_buffer/query_cache/sort_buffer/innodb_buffer_pool_size/innodb_flush_log_at_trx_commit等），也知道這些選項配置成為多少值合適；另外也了解一些特殊的配置選項，比如 知道如何搭建mysql主從同步的環境，知道各個binlog_format的區別；知道MySQL的性能追查，包括slow_log/explain等，還能夠知道基本的索引建立處理等知識；原理方面了解基本的MySQL的架構（Server+存儲引擎），知道基本的InnoDB/MyISAM索引存儲結構和不同（聚簇索引，B樹）；知道基本的InnoDB事務處理機制；了解大部分MySQL異常情況的處理方案（或者知道哪兒找到處理方案）。條件允許的情況，建議了解一下NoSQL的代表MongoDB資料庫，順便對比跟MySQL的差別，同事能夠在合適的應用場景安全謹慎的使用MongoDB，知道基本的PHP與MongoDB的結合開發。
4. Redis/Memcached
在大部分中型系統裡面一定會涉及到緩存處理，所以一定要了解基本的緩存；知道Memcached和Redis的異同和應用場景，能夠獨立安裝 Redis/Memcached，了解Memcahed的一些基本特性和限制，比如最大的value值，知道PHP跟他們的使用結合；Redis了解基本工作原理和使用，了解常規的數據類型，知道什麼場景應用什麼類型，了解Redis的事務等等。原理部分，能夠大概了解Memcached的內存結構（slab機制），redis就了解常用數據類型底層實現存儲結構（SDS/鏈表/SkipList/HashTable）等等，順便了解一下Redis的事務、RDB、AOF等機制更好。
5. PHP
除了第一階段的能力，安裝配置方面能夠隨意安裝PHP和各種第三方擴展的編譯安裝配置；了解php-fpm的大部分配置選項和含義（如max_requests/max_children/request_terminate_timeout之類的影響性能的配置），知道mod_php/fastcgi的區別；在PHP方面已經能夠熟練各種基礎技術，還包括各種深入些的PHP，包括對PHP面向對象的深入理解/SPL/語法層面的特殊特性比如反射之類的；在框架方面已經閱讀過最少一個以上常規PHP MVC框架的代碼了，知道基本PHP框架內部實現機制和設計思想；在PHP開發中已經能夠熟練使用常規的設計模式來應用開發（抽象工廠/單例/觀察者/命令鏈/策略/適配器 等模式）；建議開發自己的PHP MVC框架來充分讓開發自由化，讓自己深入理解MVC模式，也讓自己能夠在業務項目開發里快速升級；熟悉PHP的各種代碼優化方法，熟悉大部分PHP安全方面問題的解決處理；熟悉基本的PHP執行的機制原理（Zend引擎/擴展基本工作機制）。
6. C/C++
開始涉獵一定的C/C++語言，能夠寫基本的C/C++代碼，對基本的C/C++語法熟悉（指針、數組操作、字元串、常規標准API）和數據結構（鏈表、樹、哈希、隊列）有一定的熟悉下；對Linux下面的C語言開發有基本的了解概念，會簡單的makefile文件編寫，能夠使用簡單的GCC/GDB的程序編譯簡單調試工作；對基本的網路編程有大概了解。（本項是為了向更高層次打下基礎）。
7. 前端
在第一階段的基礎上面，熟悉基本的HTTP協議（協議代碼200/300/400/500，基本的HTTP交互頭）；條件允許，可以在深入寫出稍微優雅的HTML+CSS+JavaScript，或者能夠大致簡單使用某些前端框架（jQuery/YUI/ExtJS/RequireJS/BootStrap之類）；如果條件允許，可以深入學習JavaScript編程，比如閉包機制、DOM處理；再深入些可以讀讀jQuery源碼做深入學習。（本項不做重點學習，除非對前端有興趣）。
8. 系統設計
能夠設計大部分中型系統的網站架構、資料庫、基本PHP框架選型；性能測試排查處理等；能夠完成類似：瀏覽器 -> CDN(Squid) -> Nginx+PHP -> 緩存 -> 資料庫 結構網站的基本設計開發維護；能夠支撐每天數百萬到千萬流量基本網站的開發維護工作；
第三階段：高級階段 （高級PHP程序員）
重點：除了基本的LNMP程序，還能夠在某個方向或領域有深入學習。（縱深維度發展） 目標：除了能夠完成基本的PHP業務開發，還能夠解決大部分深入復雜的技術問題，並且可以獨立設計完成中大型的系統設計和開發工作；自己能夠獨立hold深入某個技術方向，在這塊比較專業。（比如在MySQL、Nginx、PHP、Redis等等任一方向深入研究）
1. Linux
除了第二階段的能力，在Linux下面除了常規的操作和性能監控跟蹤，還能夠使用很多高級復雜的命令完成工作（watch/tcpmp/starce/ldd/ar等)；在shell腳本方面，已經能夠編寫比較復雜的shell腳本（超過500行）來協助完成很多包括備份、自動化處理、監控等工作的shell；對awk/sed/perl 等應用已經如火純青，能夠隨意操作控制處理文本統計分析各種復雜格式的數據；對Linux內部機制有一些了解，對內核模塊載入，啟動錯誤處理等等有個基本的處理；同時對一些其他相關的東西也了解，比如NFS、磁碟管理等等；
2. Nginx
在第二階段的基礎上面，已經能夠把Nginx操作的很熟練，能夠對Nginx進行更深入的運維工作，比如監控、性能優化，復雜問題處理等等；看個人興趣，更多方面可以考慮側重在關於Nginx工作原理部分的深入學習，主要表現在閱讀源碼開始，比如具體的master/worker工作機制，Nginx內部的事件處理，內存管理等等；同時可以學習Nginx擴展的開發，可以定製一些自己私有的擴展；同時可以對Nginx+Lua有一定程度的了解，看看是否可以結合應用出更好模式；這個階段的要求是對Nginx原理的深入理解，可以考慮成為Nginx方向的深入專業者。
3. MySQL/MongoDB
在第二階段的基礎上面，在MySQL應用方面，除了之前的基本SQL優化，還能夠在完成一些復雜操作，比如大批量數據的導入導出，線上大批量數據的更改表結構或者增刪索引欄位等等高危操作；除了安裝配置，已經能夠處理更多復雜的MySQL的問題，比如各種問題的追查，主從同步延遲問題的解決、跨機房同步數據方案、MySQL高可用架構等都有涉及了解；對MySQL應用層面，對MySQL的核心關鍵技術比較熟悉，比如事務機制（隔離級別、鎖等）、對觸發器、分區等技術有一定了解和應用；對MySQL性能方面，有包括磁碟優化（SAS遷移到SSD）、伺服器優化（內存、伺服器本身配置）、除了二階段的其他核心性能優化選項（innodb_log_buffer_size/back_log/table_open_cache/thread_cache_size/innodb_lock_wait_timeout等）、連接池軟體選擇應用，對show *（show status/show profile）類的操作語句有深入了解，能夠完成大部分的性能問題追查；MySQL備份技術的深入熟悉，包括災備還原、對Binlog的深入理解，冷熱備份，多IDC備份等；在MySQL原理方面，有更多了解，比如對MySQL的工作機制開始閱讀部分源碼，比如對主從同步（復制）技術的源碼學習，或者對某個存儲引擎（MyISAM/Innodb/TokuDB）等等的源碼學習理解，如果條件允許，可以參考CSV引擎開發自己簡單的存儲引擎來保存一些數據，增強對MySQL的理解；在這個過程，如果自己有興趣，也可以考慮往DBA方向發展。MongoDB層面，可以考慮比如說在寫少讀多的情況開始在線上應用MongoDB，或者是做一些線上的數據分析處理的操作，具體場景可以按照工作來，不過核心是要更好的深入理解RMDBS和NoSQL的不同場景下面的應用，如果條件或者興趣允許，可以開始深入學習一下MongoDB的工作機制。
4. Redis/Memcached
在第二階段的基礎上面，能夠更深入的應用和學習。因為Memcached不是特別復雜，建議可以把源碼進行閱讀，特別是內存管理部分，方便深入理解；Redis部分，可以多做一些復雜的數據結構的應用（zset來做排行榜排序操作/事務處理用來保證原子性在秒殺類場景應用之類的使用操作）；多涉及aof等同步機制的學習應用，設計一個高可用的Redis應用架構和集群；建議可以深入的學習一下Redis的源碼，把在第二階段積累的知識都可以應用上，特別可以閱讀一下包括核心事件管理、內存管理、內部核心數據結構等充分學習了解一下。如果興趣允許，可以成為一個Redis方面非常專業的使用者。
5. PHP
作為基礎核心技能，我們在第二階段的基礎上面，需要有更深入的學習和應用。從基本代碼應用上面來說，能夠解決在PHP開發中遇到95%的問題，了解大部分PHP的技巧；對大部分的PHP框架能夠迅速在一天內上手使用，並且了解各個主流PHP框架的優缺點，能夠迅速方便項目開發中做技術選型；在配置方面，除了常規第二階段會的知識，會了解一些比較偏門的配置選項（php auto_prepend_file/auto_append_file），包括擴展中的一些復雜高級配置和原理（比如memcached擴展配置中的memcache.hash_strategy、apc擴展配置中的apc.mmap_file_mask/apc.slam_defense/apc.file_update_protection之類的）；對php的工作機制比較了解，包括php-fpm工作機制（比如php-fpm在不同配置機器下面開啟進程數量計算以及原理），對zend引擎有基本熟悉（vm/gc/stream處理），閱讀過基本的PHP內核源碼（或者閱讀過相關文章），對PHP內部機制的大部分核心數據結構（基礎類型/Array/Object）實現有了解，對於核心基礎結構（zval/hashtable/gc）有深入學習了解；能夠進行基本的PHP擴展開發，了解一些擴展開發的中高級知識（minit/rinit等），熟悉php跟apache/nginx不同的通信交互方式細節（mod_php/fastcgi）；除了開發PHP擴展，可以考慮學習開發Zend擴展，從更底層去了解PHP。
6. C/C++
在第二階段基礎上面，能夠在C/C++語言方面有更深入的學習了解，能夠完成中小型C/C++系統的開發工作；除了基本第二階段的基礎C/C++語法和數據結構，也能夠學習一些特殊數據結構（b-tree/rb-tree/skiplist/lsm-tree/trie-tree等）方便在特殊工作中需求；在系統編程方面，熟悉多進程、多線程編程；多進程情況下面了解大部分多進程之間的通信方式，能夠靈活選擇通信方式（共享內存/信號量/管道等）；多線程編程能夠良好的解決鎖沖突問題，並且能夠進行多線程程序的開發調試工作；同時對網路編程比較熟悉，了解多進程模型/多線程模型/非同步網路IO模型的差別和選型，熟悉不同非同步網路IO模型的原理和差異（select/poll/epoll/iocp等），並且熟悉常見的非同步框架（ACE/ICE/libev/libevent/libuv/Boost.ASIO等）和使用，如果閑暇也可以看看一些國產自己開發的庫（比如muo）；同時能夠設計好的高並發程序架構（leader-follow/master-worker等）；了解大部分C/C++後端Server開發中的問題（內存管理、日誌列印、高並發、前後端通信協議、服務監控），知道各個後端服務RPC通信問題（struct/http/thirft/protobuf等）；能夠更熟絡的使用GCC和GDB來開發編譯調試程序，在線上程序core掉後能夠迅速追查跟蹤解決問題；通用模塊開發方面，可以積累或者開發一些通用的工具或庫（比如非同步網路框架、日誌庫、內存池、線程池等），不過開發後是否應用要謹慎，省的埋坑去追bug。
7. 前端
深入了解HTTP協議（包括各個細致協議特殊協議代碼和背後原因，比如302靜態文件緩存了，502是nginx後面php掛了之類的）；除了之前的前端方面的各種框架應用整合能力，前端方面的學習如果有興趣可以更深入，表現形式是，可以自己開發一些類似jQuery的前端框架，或者開發一個富文本編輯器之類的比較瑣碎考驗JavaScript功力。
8. 其他領域語言學習
在基礎的PHP/C/C++語言方面有基本積累，建議在當前階段可以嘗試學習不同的編程語言，看個人興趣愛好，腳本類語言可以學學 Python/Ruby 之類的，函數式編程語言可以試試 Lisp/Haskell/Scala/Erlang 之類的，靜態語言可以試試 Java/Golang，數據統計分析可以了解了解R語言，如果想換個視角做後端業務，可以試試 Node.js還有前面提到的跟Nginx結合的Nginx_Lua等。學習不同的語言主要是提升自己的視野和解決問題手段的差異，比如會了解除了進程/線程，還有輕量級協程；比如在跨機器通信場景下面，Erlang的解決方案簡單的驚人；比如在不想選擇C/C++的情況下，還有類似高效的Erlang/Golang可用等等；主要是提升視野。
9. 其他專業方向學習
在本階段裡面，會除了基本的LNMP技能之外，會考慮一些其他領域知識的學習，這些都是可以的，看個人興趣和長期的目標方向。目前情況能夠選擇的領域比較多，比如、雲計算（分布式存儲、分布式計算、虛擬機等），機器學習（數據挖掘、模式識別等，應用到統計、個性化推薦），自然語言處理（中文分詞等），搜索引擎技術、圖形圖像、語音識別等等。除了這些高大上的，也有很多偏工程方面可以學習的地方，比如高性能系統、移動開發（Android/IOS）、計算機安全、嵌入式系統、硬體等方向。
10. 系統設計
系統設計在第二階段的基礎之上，能夠應用掌握的經驗技能，設計出比較復雜的中大型系統，能夠解決大部分線上的各種復雜系統的問題，完成類似 瀏覽器 -> CDN -> 負載均衡 ->接入層 -> Nginx+PHP -> 業務緩存 -> 資料庫 -> 各路復雜後端RPC交互（存儲後端、邏輯後端、反作弊後端、外部服務） -> 更多後端 醬紫的復雜業務；能夠支撐每天數千萬到數億流量網站的正常開發維護工作。
❸ php-fpm的工作機制
概括來說，fpm 的實現就是創建一個 master 進程，在 master 進程中創建並監聽 socket，然後 fork 出多個子進程，這些子進程各自 accept 請求，子進程的處理非常簡單，它在啟動後阻塞在 accept 上，有請求到達後開始讀取請求數據，讀取完成後開始處理然後再返回，在這期間是不會接收其它請求的，也就是說 fpm 的子進程同時只能響應一個請求，只有把這個請求處理完成後才會 accept 下一個請求，這一點與 nginx 的事件驅動有很大的區別，nginx 的子進程通過 epoll 管理套接字，如果一個請求數據還未發送完成則會處理下一個請求，即一個進程會同時連接多個請求，它是非阻塞的模型，只處理活躍的套接字。
fpm 的 master 進程與 worker 進程之間不會直接進行通信，master 通過共享內存獲取 worker 進程的信息，比如 worker 進程當前狀態、已處理請求數等，當 master 進程要殺掉一個 worker 進程時則通過發送信號的方式通知 worker 進程。
fpm 可以同時監聽多個埠，每個埠對應一個 worker pool，而每個 pool 下對應多個 worker 進程，類似 nginx 中 server 概念。
在 php-fpm.conf 中通過[pool name]聲明一個 worker pool：
啟動 fpm 後查看進程：
具體實現上 worker pool 通過fpm_worker_pool_s這個結構表示，多個 worker pool 組成一個單鏈表
接下來看下 fpm 的啟動流程，從main()函數開始：
fpm_init()主要有以下幾個關鍵操作：
(1) fpm_conf_init_main():
解析 php-fpm.conf 配置文件，分配 worker pool 內存結構並保存到全局變數中：fpm_worker_all_pools，各 worker pool 配置解析到fpm_worker_pool_s->config中。
(2)fpm_scoreboard_init_main():
分配用於記錄 worker 進程運行信息的共享內存，按照 worker pool 的最大 worker 進程數分配，每個 worker pool 分配一個fpm_scoreboard_s結構，pool 下對應的每個 worker 進程分配一個fpm_scoreboard_proc_s結構。
(3)fpm_signals_init_main():
這里會通過socketpair()創建一個管道，這個管道並不是用於 master 與 worker 進程通信的，它只在 master 進程中使用，具體用途在稍後介紹 event 事件處理時再作說明。另外設置 master 的信號處理 handler，當 master 收到 SIGTERM、SIGINT、SIGUSR1、SIGUSR2、SIGCHLD、SIGQUIT 這些信號時將調用sig_handler()處理：
(4)fpm_sockets_init_main()
創建每個 worker pool 的 socket 套接字。
(5)fpm_event_init_main():
啟動 master 的事件管理，fpm 實現了一個事件管理器用於管理 IO、定時事件，其中 IO 事件通過 kqueue、epoll、poll、select 等管理，定時事件就是定時器，一定時間後觸發某個事件。
在fpm_init()初始化完成後接下來就是最關鍵的fpm_run()操作了，此環節將 fork 子進程，啟動進程管理器，另外 master 進程將不會再返回，只有各 worker 進程會返回，也就是說fpm_run()之後的操作均是 worker 進程的。
在 fork 後 worker 進程返回了監聽的套接字繼續 main() 後面的處理，而 master 將永遠阻塞在fpm_event_loop()，接下來分別介紹 master、worker 進程的後續操作。
fpm_run()執行後將 fork 出 worker 進程，worker 進程返回main()中繼續向下執行，後面的流程就是 worker 進程不斷 accept 請求，然後執行 PHP 腳本並返回。整體流程如下：
worker 進程一次請求的處理被劃分為 5 個階段：
worker 處理到各個階段時將會把當前階段更新到fpm_scoreboard_proc_s->request_stage，master 進程正是通過這個標識判斷 worker 進程是否空閑的。
接下來我們來看下 master 是如何管理 worker 進程的，首先介紹下三種不同的進程管理方式：
前面介紹到在fpm_run()中 master 進程將進入fpm_event_loop()：
這就是 master 整體的處理，其進程管理主要依賴注冊的幾個事件，接下來我們詳細分析下這幾個事件的功能。
(1)sp[1]管道可讀事件：
在 fpm_init() 階段 master 曾創建了一個全雙工的管道：sp，然後在這里創建了一個 sp[0] 可讀的事件，當 sp[0] 可讀時將交由 fpm_got_signal() 處理，向 sp[1] 寫數據時 sp[0] 才會可讀，那麼什麼時機會向 sp[1] 寫數據呢？前面已經提到了：當 master 收到注冊的那幾種信號時會寫入 sp[1] 端，這個時候將觸發 sp[0] 可讀事件。
這個事件是 master 用於處理信號的，我們根據 master 注冊的信號逐個看下不同用途：
具體處理邏輯在 fpm_got_signal() 函數中，這里不再羅列。
(2)fpm_pctl_perform_idle_server_maintenance_heartbeat():
這是進程管理實現的主要事件，master 啟動了一個定時器，每隔 1s 觸發一次，主要用於 dynamic、ondemand 模式下的 worker 管理，master 會定時檢查各 worker pool 的 worker 進程數，通過此定時器實現 worker 數量的控制，處理邏輯如下：
(3)fpm_pctl_heartbeat():
這個事件是用於限制 worker 處理單個請求最大耗時的，php-fpm.conf 中有一個request_terminate_timeout的配置項，如果 worker 處理一個請求的總時長超過了這個值那麼 master 將會向此 worker 進程發送kill -TERM信號殺掉 worker 進程，此配置單位為秒，默認值為 0 表示關閉此機制，另外 fpm 列印的 slow log 也是在這里完成的。
除了上面這幾個事件外還有一個沒有提到，那就是 ondemand 模式下 master 監聽的新請求到達的事件，因為 ondemand 模式下 fpm 啟動時是不會預創建 worker 的，有請求時才會生成子進程，所以請求到達時需要通知 master 進程，這個事件是在fpm_children_create_initial()時注冊的，事件處理函數為fpm_pctl_on_socket_accept()，具體邏輯這里不再展開，比較容易理解。
原文出處： https://www.fanhao.com/2017/10/internal-php-fpm.html
❹ 探討nginx與php-fpm是不是以多進程多線程方式運行的
這個問題比較初級，官方文檔上的資料都是很全的。
Nginx 是非阻塞IO & IO復用模型，通過操作系統提供的類似 epoll 的功能，可以在一個線程里處理多個客戶端的請求。
Nginx 的進程就是線程，即每個進程里只有一個線程，但這一個線程可以服務多個客戶端。
PHP-FPM 是阻塞的單線程模型，pm.max_children 指定的是最大的進程數量，pm.max_requests 指定的是每個進程處理多少個請求後重啟(因為 PHP 偶爾會有內存泄漏，所以需要重啟).
PHP-FPM 的每個進程也只有一個線程，但是一個進程同時只能服務一個客戶端。
大多數的 Linux 程序都傾向於使用進程而不是線程，因為 Linux 下相對來說創建進程的開銷比較小，而 Linux 的線程功能又不是很強大。
你可以去後盾人平台看看，裡面的東西不錯
❺ 幾種常見的PHP超時處理方法
【Web伺服器超時處理】
[ Apache ]
一般在性能很高的情況下，預設所有超時配置都是30秒，但是在上傳文件，或者網路速度很慢的情況下，那麼可能觸發超時操作。
目前apachefastcgiphp-fpm模式下有三個超時設置：
fastcgi超時設置：
修改的fastcgi連接配置，類似如下：
復制代碼 代碼如下:
<IfMolemod_fastcgi.c>
FastCgiExternalServer/home/forum/apache/apache_php/cgi-bin/php-cgi-socket/home/forum/php5/etc/php-fpm.sock
ScriptAlias/fcgi-bin/"/home/forum/apache/apache_php/cgi-bin/"
AddHandlerphp-fastcgi.php
Actionphp-fastcgi/fcgi-bin/php-cgi
AddTypeapplication/x-
</IfMole>
預設配置是30s，如果需要定製自己的配置，需要修改配置，比如修改為100秒：(修改後重啟apache)：
復制代碼 代碼如下:
<IfMolemod_fastcgi.c>
FastCgiExternalServer/home/forum/apache/apache_php/cgi-bin/php-cgi-socket/home/forum/php5/etc/php-fpm.sock-idle-timeout100
ScriptAlias/fcgi-bin/"/home/forum/apache/apache_php/cgi-bin/"
AddHandlerphp-fastcgi.php
Actionphp-fastcgi/fcgi-bin/php-cgi
AddTypeapplication/x-
</IfMole>
如果超時會返回500錯誤，斷開跟後端php服務的連接，同時記錄一條apache錯誤日誌：
[ThuJan2718:30:152011][error][client10.81.41.110]FastCGI:commwithserver"/home/forum/apache/apache_php/cgi-bin/php-cgi"aborted:idletimeout(30sec)
[ThuJan2718:30:152011][error][client10.81.41.110]FastCGI:incompleteheaders(0bytes)receivedfromserver"/home/forum/apache/apache_php/cgi-bin/php-cgi"
其他fastcgi配置參數說明：
復制代碼 代碼如下:
IdleTimeout發呆時限
ProcessLifeTime一個進程的最長生命周期，過期之後無條件kill
MaxProcessCount最大進程個數
DefaultMinClassProcessCount每個程序啟動的最小進程個數
DefaultMaxClassProcessCount每個程序啟動的最大進程個數
IPCConnectTimeout程序響應超時時間
IPCCommTimeout與程序通訊的最長時間，上面的錯誤有可能就是這個值設置過小造成的
MaxRequestsPerProcess每個進程最多完成處理個數，達成後自殺
[ Lighttpd ]
配置：lig
Lighttpd配置中，關於超時的參數有如下幾個（篇幅考慮，只寫讀超時，寫超時參數同理）：
主要涉及選項：
server.max-keep-alive-idle=5
server.max-read-idle=60
server.read-timeout=0
server.max-connection-idle=360
復制代碼 代碼如下:
#每次keep-alive的最大請求數,默認值是16
server.max-keep-alive-requests=100
#keep-alive的最長等待時間,單位是秒，默認值是5
server.max-keep-alive-idle=1200
#lighttpd的work子進程數，默認值是0，單進程運行
server.max-worker=2
#限制用戶在發送請求的過程中，最大的中間停頓時間(單位是秒)，
#如果用戶在發送請求的過程中(沒發完請求)，中間停頓的時間太長，lighttpd會主動斷開連接
#默認值是60(秒)
server.max-read-idle=1200
#限制用戶在接收應答的過程中，最大的中間停頓時間(單位是秒)，
#如果用戶在接收應答的過程中(沒接完)，中間停頓的時間太長，lighttpd會主動斷開連接
#默認值是360(秒)
server.max-write-idle=12000
#讀客戶端請求的超時限制，單位是秒,配為0表示不作限制
#設置小於max-read-idle時，read-timeout生效
server.read-timeout=0
#寫應答頁面給客戶端的超時限制，單位是秒，配為0表示不作限制
#設置小於max-write-idle時，write-timeout生效
server.write-timeout=0
#請求的處理時間上限，如果用了mod_proxy_core，那就是和後端的交互時間限制,單位是秒
server.max-connection-idle=1200
說明：
對於一個keep-alive連接上的連續請求，發送第一個請求內容的最大間隔由參數max-read-idle決定，從第二個請求起，發送請求內容的最大間隔由參數max-keep-alive-idle決定。請求間的間隔超時也由max-keep-alive-idle決定。發送請求內容的總時間超時由參數read-timeout決定。Lighttpd與後端交互數據的超時由max-connection-idle決定。
延伸閱讀：
[ Nginx ]
配置：nf
復制代碼 代碼如下:
http{
#Fastcgi:(針對後端的fastcgi生效,fastcgi不屬於proxy模式)
fastcgi_connect_timeout5;#連接超時
fastcgi_send_timeout10; #寫超時
fastcgi_read_timeout10;#讀取超時
#Proxy:(針對proxy/upstreams的生效)
proxy_connect_timeout15s;#連接超時
proxy_read_timeout24s;#讀超時
proxy_send_timeout10s; #寫超時
}
說明：
Nginx 的超時設置倒是非常清晰容易理解，上面超時針對不同工作模式，但是因為超時帶來的問題是非常多的。
延伸閱讀：
ml
ml
ml
【PHP本身超時處理】
[ PHP-fpm ]
配置：nf
復制代碼 代碼如下:
<?xmlversion="1.0"?>
<configuration>
//...
.
.
EquivalenttoPHP_FCGI_.fcgi
Usedwithanypm_style.
#php-cgi的進程數量
<valuename="max_children">128</value>
Thetimeout(inseconds)
Shouldbeusedwhen'max_execution_time'
'0s'means'off'
#php-fpm 請求執行超時時間，0s為永不超時，否則設置一個 Ns 為超時的秒數
<valuename="request_terminate_timeout">0s</value>
Thetimeout(inseconds).logfile
'0s'means'off'
<valuename="request_slowlog_timeout">0s</value>
</configuration>
說明：
在php.ini中，有一個參數max_execution_time可以設置PHP腳本的最大執行時間，但是，在php-cgi(php-fpm)中，該參數不會起效。真正能夠控制PHP腳本最大執行時：
<valuename="request_terminate_timeout">0s</value>
就是說如果是使用mod_php5.so的模式運行max_execution_time是會生效的，但是如果是php-fpm模式中運行時不生效的。
延伸閱讀：
[ PHP ]
配置：php.ini
選項：
max_execution_time=30
或者在代碼里設置：
ini_set("max_execution_time",30);
set_time_limit(30);
說明：
對當前會話生效，比如設置0一直不超時，但是如果php的safe_mode打開了，這些設置都會不生效。
效果一樣，但是具體內容需要參考php-fpm部分內容，如果php-fpm中設置了request_terminate_timeout的話，那麼max_execution_time就不生效。
【後端&介面訪問超時】
【HTTP訪問】
一般我們訪問HTTP方式很多，主要是：curl,socket,file_get_contents()等方法。
如果碰到對方伺服器一直沒有響應的時候，我們就悲劇了，很容易把整個伺服器搞死，所以在訪問http的時候也需要考慮超時的問題。
[ CURL 訪問HTTP]
CURL 是我們常用的一種比較靠譜的訪問HTTP協議介面的lib庫，性能高，還有一些並發支持的功能等。
CURL:
curl_setopt($ch,opt)可以設置一些超時的設置，主要包括：
*(重要)CURLOPT_TIMEOUT設置cURL允許執行的最長秒數。
*(重要)CURLOPT_TIMEOUT_MS設置cURL允許執行的最長毫秒數。(在cURL7.16.2中被加入。從PHP5.2.3起可使用。)
CURLOPT_CONNECTTIMEOUT在發起連接前等待的時間，如果設置為0，則無限等待。
CURLOPT_CONNECTTIMEOUT_MS嘗試連接等待的時間，以毫秒為單位。如果設置為0，則無限等待。在cURL7.16.2中被加入。從PHP5.2.3開始可用。
CURLOPT_DNS_CACHE_TIMEOUT設置在內存中保存DNS信息的時間，默認為120秒。
curl普通秒級超時：
$ch=curl_init();
curl_setopt($ch,CURLOPT_URL,$url);
curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);
curl_setopt($ch,CURLOPT_TIMEOUT,60);//只需要設置一個秒的數量就可以
curl_setopt($ch,CURLOPT_HTTPHEADER,$headers);
curl_setopt($ch,CURLOPT_USERAGENT,$defined_vars['HTTP_USER_AGENT']);
curl普通秒級超時使用：
curl_setopt($ch,CURLOPT_TIMEOUT,60);
curl如果需要進行毫秒超時，需要增加：
curl_easy_setopt(curl,CURLOPT_NOSIGNAL,1L);
或者是：
curl_setopt($ch,CURLOPT_NOSIGNAL,true);是可以支持毫秒級別超時設置的
curl一個毫秒級超時的例子：
復制代碼 代碼如下:
<?php
if(!isset($_GET['foo'])){
//Client
$ch=curl_init('');
curl_setopt($ch,CURLOPT_RETURNTRANSFER,true);
curl_setopt($ch,CURLOPT_NOSIGNAL,1);//注意，毫秒超時一定要設置這個
curl_setopt($ch,CURLOPT_TIMEOUT_MS,200);//超時毫秒，cURL7.16.2中被加入。從PHP5.2.3起可使用
$data=curl_exec($ch);
$curl_errno=curl_errno($ch);
$curl_error=curl_error($ch);
curl_close($ch);
if($curl_errno>0){
echo"cURLError($curl_errno):$curl_errorn";
}else{
echo"Datareceived:$datan";
}
}else{
//Server
sleep(10);
echo"Done.";
}
?>
其他一些技巧：
1. 按照經驗總結是：cURL版本>=libcurl/7.21.0版本，毫秒級超時是一定生效的，切記。
2. curl_multi的毫秒級超時也有問題。。單次訪問是支持ms級超時的，curl_multi並行調多個會不準
[流處理方式訪問HTTP]
除了curl，我們還經常自己使用fsockopen、或者是file操作函數來進行HTTP協議的處理，所以，我們對這塊的超時處理也是必須的。
一般連接超時可以直接設置，但是流讀取超時需要單獨處理。
自己寫代碼處理:
復制代碼 代碼如下:
$tmCurrent=gettimeofday();
$intUSGone=($tmCurrent['sec']-$tmStart['sec'])*1000000
+($tmCurrent['usec']-$tmStart['usec']);
if($intUSGone>$this->_intReadTimeoutUS){
returnfalse;
}
或者使用內置流處理函數stream_set_timeout()和stream_get_meta_data()處理：
復制代碼 代碼如下:
<?php
//Timeoutinseconds
$timeout=5;
$fp=fsockopen("",80,$errno,$errstr,$timeout);
if($fp){
fwrite($fp,"GET/HTTP/1.0rn");
fwrite($fp,"Host:rn");
fwrite($fp,"Connection:Closernrn");
stream_set_blocking($fp,true);//重要，設置為非阻塞模式
stream_set_timeout($fp,$timeout);//設置超時
$info=stream_get_meta_data($fp);
while((!feof($fp))&&(!$info['timed_out'])){
$data.=fgets($fp,4096);
$info=stream_get_meta_data($fp);
ob_flush;
flush();
}
if($info['timed_out']){
echo"ConnectionTimedOut!";
}else{
echo$data;
}
}
file_get_contents超時：
復制代碼 代碼如下:
<?php
$timeout=array(
'http'=>array(
'timeout'=>5//設置一個超時時間，單位為秒
)
);
$ctx=stream_context_create($timeout);
$text=file_get_contents("",0,$ctx);
?>
fopen超時：
復制代碼 代碼如下:
<?php
$timeout=array(
'http'=>array(
'timeout'=>5//設置一個超時時間，單位為秒
)
);
$ctx=stream_context_create($timeout);
if($fp=fopen("","r",false,$ctx)){
while($c=fread($fp,8192)){
echo$c;
}
fclose($fp);
}
?>
【MySQL】
php中的mysql客戶端都沒有設置超時的選項，mysqli和mysql都沒有，但是libmysql是提供超時選項的，只是我們在php中隱藏了而已。
那麼如何在PHP中使用這個操作捏，就需要我們自己定義一些MySQL操作常量，主要涉及的常量有：
MYSQL_OPT_READ_TIMEOUT=11;
MYSQL_OPT_WRITE_TIMEOUT=12;
這兩個，定義以後，可以使用options設置相應的值。
不過有個注意點，mysql內部實現：
1.超時設置單位為秒，最少配置1秒
2.但mysql底層的read會重試兩次，所以實際會是3秒
重試兩次+自身一次=3倍超時時間，那麼就是說最少超時時間是3秒，不會低於這個值，對於大部分應用來說可以接受，但是對於小部分應用需要優化。
查看一個設置訪問mysql超時的php實例：
復制代碼 代碼如下:
<?php
//自己定義讀寫超時常量
if(!defined('MYSQL_OPT_READ_TIMEOUT')){
define('MYSQL_OPT_READ_TIMEOUT',11);
}
if(!defined('MYSQL_OPT_WRITE_TIMEOUT')){
define('MYSQL_OPT_WRITE_TIMEOUT',12);
}
//設置超時
$mysqli=mysqli_init();
$mysqli->options(MYSQL_OPT_READ_TIMEOUT,3);
$mysqli->options(MYSQL_OPT_WRITE_TIMEOUT,1);
//連接資料庫
$mysqli->real_connect("localhost","root","root","test");
if(mysqli_connect_errno()){
printf("Connectfailed:%s/n",mysqli_connect_error());
exit();
}
//執行查詢sleep1秒不超時
printf("Hostinformation:%s/n",$mysqli->host_info);
if(!($res=$mysqli->query('selectsleep(1)'))){
echo"query1error:".$mysqli->error."/n";
}else{
echo"Query1:querysuccess/n";
}
//執行查詢sleep9秒會超時
if(!($res=$mysqli->query('selectsleep(9)'))){
echo"query2error:".$mysqli->error."/n";
}else{
echo"Query2:querysuccess/n";
}
$mysqli->close();
echo"closemysqlconnection/n";
?>
延伸閱讀：
【Memcached】
[PHP擴展]
php_memcache客戶端：
連接超時：boolMemcache::connect(string$host[,int$port[,int$timeout]])
在get和set的時候，都沒有明確的超時設置參數。
libmemcached客戶端：在php介面沒有明顯的超時參數。
說明：所以說，在PHP中訪問Memcached是存在很多問題的，需要自己hack部分操作，或者是參考網上補丁。
[C&C++訪問Memcached]
客戶端：libmemcached客戶端
說明：memcache超時配置可以配置小點，比如5，10個毫秒已經夠用了，超過這個時間還不如從資料庫查詢。
下面是一個連接和讀取set數據的超時的C++示例：
復制代碼 代碼如下:
//創建連接超時（連接到Memcached）
memcached_st*MemCacheProxy::_create_handle()
{
memcached_st*mmc=NULL;
memcached_return_tprc;
if(_mpool!=NULL){//getfrompool
mmc=memcached_pool_pop(_mpool,false,&prc);
if(mmc==NULL){
__LOG_WARNING__("MemCacheProxy","gethandlefrompoolerror[%d]",(int)prc);
}
returnmmc;
}
memcached_st*handle=memcached_create(NULL);
if(handle==NULL){
__LOG_WARNING__("MemCacheProxy","create_handleerror");
returnNULL;
}
//設置連接/讀取超時
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_HASH,MEMCACHED_HASH_DEFAULT);
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_NO_BLOCK,_noblock);//參數MEMCACHED_BEHAVIOR_NO_BLOCK為1使超時配置生效，不設置超時會不生效，關鍵時候會悲劇的，容易引起雪崩
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT,_connect_timeout);//連接超時
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_RCV_TIMEOUT,_read_timeout);//讀超時
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_SND_TIMEOUT,_send_timeout);//寫超時
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_POLL_TIMEOUT,_poll_timeout);
//設置一致hash
//memcached_behavior_set_distribution(handle,MEMCACHED_DISTRIBUTION_CONSISTENT);
memcached_behavior_set(handle,MEMCACHED_BEHAVIOR_DISTRIBUTION,MEMCACHED_DISTRIBUTION_CONSISTENT);
memcached_returnrc;
for(uinti=0;i<_server_count;i++){
rc=memcached_server_add(handle,_ips[i],_ports[i]);
if(MEMCACHED_SUCCESS!=rc){
__LOG_WARNING__("MemCacheProxy","addserver[%s:%d]failed.",_ips[i],_ports[i]);
}
}
_mpool=memcached_pool_create(handle,_min_connect,_max_connect);
if(_mpool==NULL){
__LOG_WARNING__("MemCacheProxy","create_poolerror");
returnNULL;
}
mmc=memcached_pool_pop(_mpool,false,&prc);
if(mmc==NULL){
__LOG_WARNING__("MyMemCacheProxy","gethandlefrompoolerror[%d]",(int)prc);
}
//__LOG_DEBUG__("MemCacheProxy","gethandle[%p]",handle);
returnmmc;
}
//設置一個key超時（set一個數據到memcached）
boolMemCacheProxy::_add(memcached_st*handle,unsignedint*key,constchar*value,intlen,unsignedinttimeout)
{
memcached_returnrc;
chartmp[1024];
snprintf(tmp,sizeof(tmp),"%u#%u",key[0],key[1]);
//有個timeout值
rc=memcached_set(handle,tmp,strlen(tmp),(char*)value,len,timeout,0);
if(MEMCACHED_SUCCESS!=rc){
returnfalse;
}
returntrue;
}
//Memcache讀取數據超時(沒有設置)
libmemcahed源碼中介面定義：
LIBMEMCACHED_APIchar*memcached_get(memcached_st*ptr,constchar*key,size_tkey_length,size_t*value_length,uint32_t*flags,memcached_return_t*error);
LIBMEMCACHED_APImemcached_return_tmemcached_mget(memcached_st*ptr,constchar*const*keys,constsize_t*key_length,size_tnumber_of_keys);
從介面中可以看出在讀取數據的時候，是沒有超時設置的。
延伸閱讀：
【如何實現超時】
程序中需要有超時這種功能，比如你單獨訪問一個後端Socket模塊，Socket模塊不屬於我們上面描述的任何一種的時候，它的協議也是私有的，那麼這個時候可能需要自己去實現一些超時處理策略，這個時候就需要一些處理代碼了。
[PHP中超時實現]
一、初級：最簡單的超時實現 （秒級超時）
思路很簡單：鏈接一個後端，然後設置為非阻塞模式，如果沒有連接上就一直循環，判斷當前時間和超時時間之間的差異。
phpsocket中實現原始的超時：(每次循環都當前時間去減，性能會很差，cpu佔用會較高)
復制代碼 代碼如下:
<?
$host="127.0.0.1";
$port="80";
$timeout=15;//timeoutinseconds
$socket=socket_create(AF_INET,SOCK_STREAM,SOL_TCP)
ordie("Unabletocreatesocketn");
socket_set_nonblock($socket) //務必設置為阻塞模式
ordie("Unabletosetnonblockonsocketn");
$time=time();
//循環的時候每次都減去相應值
while(!@socket_connect($socket,$host,$port))//如果沒有連接上就一直死循環
{
$err=socket_last_error($socket);
if($err==115||$err==114)
{
if((time()-$time)>=$timeout)//每次都需要去判斷一下是否超時了
{
socket_close($socket);
die("Connectiontimedout.n");
}
sleep(1);
continue;
}
die(socket_strerror($err)."n");
}
socket_set_block($this->socket)//還原阻塞模式
ordie("Unabletosetblockonsocketn");
?>
二、升級：使用PHP自帶非同步IO去實現（毫秒級超時）
說明：
非同步IO：非同步IO的概念和同步IO相對。當一個非同步過程調用發出後，調用者不能立刻得到結果。實際處理這個調用的部件在完成後，通過狀態、通知和回調來通知調用者。非同步IO將比特分成小組進行傳送，小組可以是8位的1個字元或更長。發送方可以在任何時刻發送這些比特組，而接收方從不知道它們會在什麼時候到達。
多路復用：復用模型是對多個IO操作進行檢測，返回可操作集合，這樣就可以對其進行操作了。這樣就避免了阻塞IO不能隨時處理各個IO和非阻塞佔用系統資源的確定。
使用socket_select()實現超時
socket_select(...,floor($timeout),ceil($timeout*1000000));
select的特點：能夠設置到微秒級別的超時！
使用socket_select()的超時代碼（需要了解一些非同步IO編程的知識去理解）
復制代碼 代碼如下:
編程 調用類 編程#
<?php
$server=newServer;
$client=newClient;
for(;;){
foreach($select->can_read(0)as$socket){
if($socket==$client->socket){
//NewClientSocket
$select->add(socket_accept($client->socket));
}
else{
//there'ssomethingtoreadon$socket
}
}
}
?>
編程 非同步多路復用IO & 超時連接處理類 編程
<?php
classselect{
var$sockets;
functionselect($sockets){
$this->sockets=array();
foreach($socketsas$socket){
$this->add($socket);
}
}
functionadd($add_socket){
array_push($this->sockets,$add_socket);
}
functionremove($remove_socket){
$sockets=array();
foreach($this->socketsas$socket){
if($remove_socket!=$socket)
$sockets[]=$socket;
}
$this->sockets=$sockets;
}
functioncan_read($timeout){
$read=$this->sockets;
socket_select($read,$write=NULL,$except=NULL,$timeout);
return$read;
}
functioncan_write($timeout){
$write=$this->sockets;
socket_select($read=NULL,$write,$except=NULL,$timeout);
return$write;
}
}
?>
[C&C++中超時實現]
一般在LinuxC/C++中，可以使用：alarm()設置定時器的方式實現秒級超時，或者：select()、poll()、epoll()之類的非同步復用IO實現毫秒級超時。也可以使用二次封裝的非同步io庫（libevent,libev）也能實現。
一、使用alarm中用信號實現超時 （秒級超時）
說明：Linux內核connect超時通常為75秒，我們可以設置更小的時間如10秒來提前從connect中返回。這里用使用信號處理機制，調用alarm，超時後產生SIGALRM信號（也可使用select實現）
用alarym秒級實現connect設置超時代碼示例：
復制代碼 代碼如下:
//信號處理函數
staticvoidconnect_alarm(intsigno)
{
debug_printf("SignalHandler");
return;
}
//alarm超時連接實現
staticvoidconn_alarm()
{
Sigfunc*sigfunc;//現有信號處理函數
sigfunc=signal(SIGALRM,connect_alarm);//建立信號處理函數connect_alarm,(如果有)保存現有的信號處理函數
inttimeout=5;
//設置鬧鍾
if(alarm(timeout)!=0){
//...鬧鍾已經設置處理
}
//進行連接操作
if(connect(m_Socket,(structsockaddr*)&addr,sizeof(addr))<0){
if(errno==EINTR){//如果錯誤號設置為EINTR，說明超時中斷了
debug_printf("Timeout");
❻ php伺服器用IIS好還是用Apache好，其他的伺服器怎麼樣
看你的項目，apache肯定好於iis的，但是apache和nginx之間也是有區別的。
輕量級，同樣起web 服務，比apache 佔用更少的內存及資源 ，抗並發，nginx 處理請求是非同步非阻塞的，而apache 則是阻塞型的，在高並發下nginx 能保持低資源低消耗高性能 ,高度模塊化的設計，編寫模塊相對簡單,社區活躍，各種高性能模塊出品迅速啊
apache 相對於nginx 的優點：
rewrite ，比nginx 的rewrite 強大,模塊超多，基本想到的都可以找到,少bug ，nginx 的bug 相對較多,超穩定,存在就是理由，一般來說，需要性能的web 服務，用nginx 。如果不需要性能只求穩定，那就apache 吧。後者的各種功能模塊實現得比前者，例如ssl 的模塊就比前者好，可配置項多。這里要注意一點，epoll(freebsd 上是 kqueue )網路IO 模型是nginx 處理性能高的根本理由，但並不是所有的情況下都是epoll 大獲全勝的，如果本身提供靜態服務的就只有寥寥幾個文件，apache 的select 模型或許比epoll 更高性能。當然，這只是根據網路IO 模型的原理作的一個假設，真正的應用還是需要實測了再說的。
---------------------