phpepoll
1. php新手學習路線是怎樣的
第一階段：基礎階段（基礎PHP程序員）
重點：把LNMP搞熟練（核心是安裝配置基本操作） 目標：能夠完成基本的LNMP系統安裝，簡單配置維護；能夠做基本的簡單系統的PHP開發；能夠在PHP中型系統中支持某個PHP功能模塊的開發。
時間：完成本階段的時間因人而異，有的成長快半年一年就過了，成長慢的兩三年也有。
基本命令、操作、啟動、基本服務配置（包括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交互（存儲後端、邏輯後端、反作弊後端、外部服務） -> 更多後端 醬紫的復雜業務；能夠支撐每天數千萬到數億流量網站的正常開發維護工作。
2. 幾種常見的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");
3. php 怎麼做mysql的線程池
one-connection-per-thread
根據scheler_functions的模板，我們也可以列出one-connection-per-thread方式的幾個關鍵函數。
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
static scheler_functions con_per_functions=
{ max_connection+1, // max_threads
NULL,
NULL,
NULL, // init
Init_new_connection_handler_thread, // init_new_connection_thread
create_thread_to_handle_connection, // add_connection
NULL, // thd_wait_begin
NULL, // thd_wait_end
NULL, // post_kill_notification
one_thread_per_connection_end, // end_thread
NULL // end
};
1.init_new_connection_handler_thread
這個介面比較簡單，主要是調用pthread_detach，將線程設置為detach狀態，線程結束後自動釋放所有資源。
2.create_thread_to_handle_connection
這個介面是處理新連接的介面，對於線程池而言，會從thread_id%group_size對應的group中獲取一個線程來處理，而one-connection-per-thread方式則會判斷是否有thread_cache可以使用，如果沒有則新建線程來處理。具體邏輯如下：
(1).判斷緩存的線程數是否使用完(比較blocked_pthread_count 和wake_pthread大小)
(2).若還有緩存線程，將thd加入waiting_thd_list的隊列，喚醒一個等待COND_thread_cache的線程
(3).若沒有，創建一個新的線程處理,線程的入口函數是do_handle_one_connection
(4).調用add_global_thread加入thd數組。
3.do_handle_one_connection
這個介面被create_thread_to_handle_connection調用，處理請求的主要實現介面。
(1).循環調用do_command，從socket中讀取網路包，並且解析執行；
(2). 當遠程客戶端發送關閉連接COMMAND(比如COM_QUIT，COM_SHUTDOWN)時，退出循環
(3).調用close_connection關閉連接(thd->disconnect());
(4).調用one_thread_per_connection_end函數,確認是否可以復用線程
(5).根據返回結果，確定退出工作線程還是繼續循環執行命令。
4.one_thread_per_connection_end
判斷是否可以復用線程(thread_cache)的主要函數,邏輯如下：
(1).調用remove_global_thread，移除線程對應的thd實例
(2).調用block_until_new_connection判斷是否可以重用thread
(3).判斷緩存的線程是否超過閥值，若沒有，則blocked_pthread_count++;
(4).阻塞等待條件變數COND_thread_cache
(5).被喚醒後，表示有新的thd需要重用線程，將thd從waiting_thd_list中移除，使用thd初始化線程的thd->thread_stack
(6).調用add_global_thread加入thd數組。
(7).如果可以重用，返回false，否則返回ture
線程池與epoll
在引入線程池之前，server層只有一個監聽線程，負責監聽mysql埠和本地unixsocket的請求，對於每個新的連接，都會分配一個獨立線程來處理，因此監聽線程的任務比較輕松，mysql通過poll或select方式來實現IO的多路復用。引入線程池後，除了server層的監聽線程，每個group都有一個監聽線程負責監聽group內的所有連接socket的連接請求，工作線程不負責監聽，只處理請求。對於overscribe為1000的線程池設置，每個監聽線程需要監聽1000個socket的請求，監聽線程採用epoll方式來實現監聽。
Select,poll,epoll都是IO多路復用機制，IO多路復用通過一種機制，可以監聽多個fd(描述符)，比如socket，一旦某個fd就緒(讀就緒或寫就緒)，能夠通知程序進行相應的讀寫操作。epoll相對於select和poll有了很大的改進，首先epoll通過epoll_ctl函數注冊，注冊時，將所有fd拷貝進內核，只拷貝一次不需要重復拷貝，而每次調用poll或select時，都需要將fd集合從用戶空間拷貝到內核空間(epoll通過epoll_wait進行等待)；其次，epoll為每個描述符指定了一個回調函數，當設備就緒時，喚醒等待者，通過回調函數將描述符加入到就緒鏈表，無需像select，poll方式採用輪詢方式；最後select默認只支持1024個fd，epoll則沒有限制，具體數字可以參考cat /proc/sys/fs/file-max的設置。epoll貫穿在線程池使用的過程中，下面我就epoll的創建，使用和銷毀生命周期來描述epoll在線程中是如何使用的。
線程池初始化，epoll通過epoll_create函數創建epoll文件描述符，實現函數是thread_group_init；
埠監聽線程監聽到請求後，創建socket，並創建THD和connection對象，放在對應的group隊列中；
工作線程獲取該connection對象時，若還未登錄，則進行登錄驗證
若socket還未注冊到epoll，則調用epoll_ctl進行注冊,注冊方式是EPOLL_CTL_ADD，並將connection對象放入epoll_event結構體中
若是老連接的請求，仍然需要調用epoll_ctl注冊，注冊方式是EPOLL_CTL_MOD
group內的監聽線程調用epoll_wait來監聽注冊的fd，epoll是一種同步IO方式，所以會進行等待
請求到來時，獲取epoll_event結構體中的connection，放入到group中的隊列
線程池銷毀時，調用thread_group_close將epoll關閉。
備註：
1.注冊在epoll的fd，若請求就緒，則將對應的event放入到events數組，並將該fd的事務類型清空，因此對於老的連接請求，依然需要調用epoll_ctl(pollfd, EPOLL_CTL_MOD, fd, &ev)來注冊。
線程池函數調用關系
(1)創建epoll
tp_init->thread_group_init->tp_set_threadpool_size->io_poll_create->epoll_create
(2)關閉epoll
tp_end->thread_group_close->thread_group_destroy->close(pollfd)
(3)關聯socket描述符
handle_event->start_io->io_poll_associate_fd->io_poll_start_read->epoll_ctl
(4)處理連接請求
handle_event->threadpool_process_request->do_command->dispatch_command->mysql_parse->mysql_execute_command
(5)工作線程空閑時
worker_main->get_event->pthread_cond_timedwait
等待thread_pool_idle_timeout後，退出。
(6)監聽epoll
worker_main->get_event->listener->io_poll_wait->epoll_wait
(7)埠監聽線程
main->mysqld_main->handle_connections_sockets->poll
one-connection-per-thread函數調用關系
(1) 工作線程等待請求
handle_one_connection->do_handle_one_connection->do_command->
my_net_read->net_read_packet->net_read_packet_header->net_read_raw_loop->
vio_read->vio_socket_io_wait->vio_io_wait->poll
備註：與線程池的工作線程有監聽線程幫助其監聽請求不同，one-connection-per-thread方式的工作線程在空閑時，會調用poll阻塞等待網路包過來；
而線程池的工作線程只需要專心處理請求即可，所以使用也更充分。
(2)埠監聽線程
與線程池的(7)相同
參考文檔
http://www.cnblogs.com/Anker/p/3265058.html
http://blog.csdn.net/zhanglu5227/article/details/7960677
4. 為何asp被成為過時，現在都是php
讓我來跟你談一下吧...
第一,php開源,動一下腦子.什麼大公司會想依靠別人的東西?能不用當然是不用為好啦
第二,php開源，它能通過源碼擴展．按須要擴展PHP．你有能力，PHP無所不能
第三,php開源.大家都喜歡開源的東西.動不動就收保護費,誰會喜歡啊
第四,php 開源,能很好地在開源伺服器Linux上跑,簡直就是天衣無縫啊
第五,php開源.因為開源,可以在Linux 跑.而現在公認的伺服器是Linux.還有linux2.6後加上了epoll,nginx又加入了這行列.使得php如虎添翼．
第六，php開源.很多源碼．開發速度快
第七，．．．．．．．．．．．
．．．．．．．．
好吧，不想說了，至於你說asp好，那我也不知說什麼好．大潮流的環境下．要殺一個英雄有何難．根本什麼理由都不用．．
5. 常用的php環境套件有哪些
護衛神.php套件。可以選擇7個版本。不過他們還有更好的選擇，護衛神.主機大師、護衛神.apache大師，都支持自動安裝PHP+MYSQL，而且支持7個版本的PHP同時使用。
6. 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 模型的原理作的一個假設，真正的應用還是需要實測了再說的。
---------------------
7. 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
8. 如何讓epoll中斷返回
如何讓epoll中斷返回？轉自：http://blog.chinaunix.net/link.php?url=http://blog.csdn.net%2Frussell_tao%2Farticle%2Fdetails%2F7160071
開發高性能網路程序時，windows開發者們言必稱iocp，linux開發者們則言必稱epoll。大家都明白epoll是一種IO多路復用技術，可以非常高效的處理數以百萬計的socket句柄，比起以前的select和poll效率高大發了。我們用起epoll來都感覺挺爽，確實快，那麼，它到底為什麼可以高速處理這么多並發連接呢？
先簡單回顧下如何使用C庫封裝的3個epoll系統調用吧。
1 int epoll_create(int size);
2 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
3 int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
使用起來很清晰，首先要調用epoll_create建立一個epoll對象。參數size是內核保證能夠正確處理的最大句柄數，多於這個最大數時內核可不保證效果。
epoll_ctl可以操作上面建立的epoll，例如，將剛建立的socket加入到epoll中讓其監控，或者把 epoll正在監控的某個socket句柄移出epoll，不再監控它等等。
epoll_wait在調用時，在給定的timeout時間內，當在監控的所有句柄中有事件發生時，就返回用戶態的進程。
從上面的調用方式就可以看到epoll比select/poll的優越之處：因為後者每次調用時都要傳遞你所要監控的所有socket給select/poll系統調用，這意味著需要將用戶態的socket列表到內核態，如果以萬計的句柄會導致每次都要幾十幾百KB的內存到內核態，非常低效。而我們調用epoll_wait時就相當於以往調用select/poll，但是這時卻不用傳遞socket句柄給內核，因為內核已經在epoll_ctl中拿到了要監控的句柄列表。
所以，實際上在你調用epoll_create後，內核就已經在內核態開始准備幫你存儲要監控的句柄了，每次調用epoll_ctl只是在往內核的數據結構里塞入新的socket句柄。
在內核里，一切皆文件。所以，epoll向內核注冊了一個文件系統，用於存儲上述的被監控socket。當你調用epoll_create時，就會在這個虛擬的epoll文件系統里創建一個file結點。當然這個file不是普通文件，它只服務於epoll。
epoll在被內核初始化時（操作系統啟動），同時會開辟出epoll自己的內核高速cache區，用於安置每一個我們想監控的socket，這些socket會以紅黑樹的形式保存在內核cache里，以支持快速的查找、插入、刪除。這個內核高速cache區，就是建立連續的物理內存頁，然後在之上建立slab層，簡單的說，就是物理上分配好你想要的size的內存對象，每次使用時都是使用空閑的已分配好的對象。
1 static int __init eventpoll_init(void)
2 {
3 ... ...
4
5 /* Allocates slab cache used to allocate "struct epitem" items */
6 epi_cache = kmem_cache_create("eventpoll_epi", sizeof(struct epitem),
7 0, SLAB_HWCACHE_ALIGN|EPI_SLAB_DEBUG|SLAB_PANIC,
8 NULL, NULL);
9
10 /* Allocates slab cache used to allocate "struct eppoll_entry" */
11 pwq_cache = kmem_cache_create("eventpoll_pwq",
12 sizeof(struct eppoll_entry), 0,
13 EPI_SLAB_DEBUG|SLAB_PANIC, NULL, NULL);
14
15 ... ...
epoll的高效就在於，當我們調用epoll_ctl往裡塞入百萬個句柄時，epoll_wait仍然可以飛快的返回，並有效的將發生事件的句柄給我們用戶。這是由於我們在調用epoll_create時，內核除了幫我們在epoll文件系統里建了個file結點，在內核cache里建了個紅黑樹用於存儲以後epoll_ctl傳來的socket外，還會再建立一個list鏈表，用於存儲准備就緒的事件，當epoll_wait調用時，僅僅觀察這個list鏈表裡有沒有數據即可。有數據就返回，沒有數據就sleep，等到timeout時間到後即使鏈表沒數據也返回。所以，epoll_wait非常高效。
而且，通常情況下即使我們要監控百萬計的句柄，大多一次也只返回很少量的准備就緒句柄而已，所以，epoll_wait僅需要從內核態少量的句柄到用戶態而已，如何能不高效？！
那麼，這個准備就緒list鏈表是怎麼維護的呢？當我們執行epoll_ctl時，除了把socket放到epoll文件系統里file對象對應的紅黑樹上之外，還會給內核中斷處理程序注冊一個回調函數，告訴內核，如果這個句柄的中斷到了，就把它放到准備就緒list鏈表裡。所以，當一個socket上有數據到了，內核在把網卡上的數據到內核中後就來把socket插入到准備就緒鏈表裡了。
如此，一顆紅黑樹，一張准備就緒句柄鏈表，少量的內核cache，就幫我們解決了大並發下的socket處理問題。執行epoll_create時，創建了紅黑樹和就緒鏈表，執行epoll_ctl時，如果增加socket句柄，則檢查在紅黑樹中是否存在，存在立即返回，不存在則添加到樹幹上，然後向內核注冊回調函數，用於當中斷事件來臨時向准備就緒鏈表中插入數據。執行epoll_wait時立刻返回准備就緒鏈表裡的數據即可。
最後看看epoll獨有的兩種模式LT和ET。無論是LT和ET模式，都適用於以上所說的流程。區別是，LT模式下，只要一個句柄上的事件一次沒有處理完，會在以後調用epoll_wait時次次返回這個句柄，而ET模式僅在第一次返回。
這件事怎麼做到的呢？當一個socket句柄上有事件時，內核會把該句柄插入上面所說的准備就緒list鏈表，這時我們調用epoll_wait，會把准備就緒的socket拷貝到用戶態內存，然後清空准備就緒list鏈表，最後，epoll_wait幹了件事，就是檢查這些socket，如果不是ET模式（就是LT模式的句柄了），並且這些socket上確實有未處理的事件時，又把該句柄放回到剛剛清空的准備就緒鏈表了。所以，非ET的句柄，只要它上面還有事件，epoll_wait每次都會返回。而ET模式的句柄，除非有新中斷到，即使socket上的事件沒有處理完，也是不會次次從epoll_wait返回的。
1 /*
2 * Each file descriptor added to the eventpoll interface will
3 * have an entry of this type linked to the hash.
4 */
5 struct epitem {
6 /* RB-Tree node used to link this structure to the eventpoll rb-tree */
7 struct rb_node rbn;
8 //紅黑樹，用來保存eventpoll
9
10 /* List header used to link this structure to the eventpoll ready list */
11 struct list_head rdllink;
12 //雙向鏈表，用來保存已經完成的eventpoll
13
14 /* The file descriptor information this item refers to */
15 struct epoll_filefd ffd;
16 //這個結構體對應的被監聽的文件描述符信息
17
18 /* Number of active wait queue attached to poll operations */
19 int nwait;
20 //poll操作中事件的個數
21
22 /* List containing poll wait queues */
23 struct list_head pwqlist;
24 //雙向鏈表，保存著被監視文件的等待隊列，功能類似於select/poll中的poll_table
25
26 /* The "container" of this item */
27 struct eventpoll *ep;
28 //指向eventpoll，多個epitem對應一個eventpoll
29
30 /* The structure that describe the interested events and the source fd */
31 struct epoll_event event;
32 //記錄發生的事件和對應的fd
33
34 /*
35 * Used to keep track of the usage count of the structure. This avoids
36 * that the structure will desappear from underneath our processing.
37 */
38 atomic_t usecnt;
39 //引用計數
40
41 /* List header used to link this item to the "struct file" items list */
42 struct list_head fllink;
43 雙向鏈表，用來鏈接被監視的文件描述符對應的struct file。因為file里有f_ep_link,用來保存所有監視這個文件的epoll節點
44
45 /* List header used to link the item to the transfer list */
46 struct list_head txlink;
47 雙向鏈表，用來保存傳輸隊列
48
49 /*
50 * This is used ring the collection/transfer of events to userspace
51 * to pin items empty events set.
52 */
53 unsigned int revents;
54 //文件描述符的狀態，在收集和傳輸時用來鎖住空的事件集合
55 };
56
57 //該結構體用來保存與epoll節點關聯的多個文件描述符，保存的方式是使用紅黑樹實現的hash表.
58 //至於為什麼要保存，下文有詳細解釋。它與被監聽的文件描述符一一對應.
59 struct eventpoll {
60 /* Protect the this structure access */
61 rwlock_t lock;
62 //讀寫鎖
63
64 /*
65 * This semaphore is used to ensure that files are not removed
66 * while epoll is using them. This is read-held ring the event
67 * collection loop and it is write-held ring the file cleanup
68 * path, the epoll file exit code and the ctl operations.
69 */
70 struct rw_semaphore sem;
71 //讀寫信號量
72
73 /* Wait queue used by sys_epoll_wait() */
74 wait_queue_head_t wq;
75 /* Wait queue used by file->poll() */
76
77 wait_queue_head_t poll_wait;
78 /* List of ready file descriptors */
79
80 struct list_head rdllist;
81 //已經完成的操作事件的隊列。
82
83 /* RB-Tree root used to store monitored fd structs */
84 struct rb_root rbr;
85 //保存epoll監視的文件描述符
86 };