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 };