PHP Web System Optimization(undone)

0. 引言
1. PHP Pool
2. listen
3. Process Manage(PM)
4. pm.max_children
5. PHP DB Connection Pool(数据库连接池)

1. 将多台web server配置成集群模式，在集群的前端(逻辑)部署Load Balance Server，将客户端的访问请求"平均地"负载到集群的子节点server中
2. 在Load Balance Server和集群之间部署Cache Server，例如对于典型的DB驱动型的应用，使用Redis代替直接Mysql连接就是一个很好的实践
    1) 对于insert操作，在向mysql插入的同时，向redis中也保存一份
    2) 对于select操作，优先从redis中查询，如果命中失败，再从mysql中查询
3. 集群中的web server采用nginx+php-fpm的组合，nginx在高并发情况下的表现比apache要更好
4. 针对web server上的业务代码进行逻辑优化
5. 将单点的DB，例如mysql，改为读写分离的主从集群架构 
6. 使用DB Connection Pool(数据库连接池)代替每次请求都重新创建并销毁DB连接的操作

1. Apache：mod_php5
2. IIS：ISAPI
3. SHELL：CLI

1. Apache + mod_php 
2. Apache + mod_fastcgi
3. nginx + php-fpm  

在mod_php的源码中，函数sapi_cgibin_ub_write()直接调用了apache的ap_write函数，所以，用mod_php，我们可以把php和apache看成一个模块，两者绑定在一起

从源码中可以看到，对于cgi的sapi它是把结果输出到fastcgi提供的stdout上，fastcgi再将数据返回给httpd完成交互

1. 支持平滑停止/启动的高级进程管理功能 
2. 可以工作于不同的 uid/gid/chroot 环境下，并监听不同的端口和使用不同的 php.ini 配置文件(可取代 safe_mode 的设置)
3. stdout 和 stderr 日志记录
4. 在发生意外情况的时候能够重新启动并缓存被破坏的 opcode 
5. 文件上传优化支持 
6. "慢日志" - 记录脚本(不仅记录文件名，还记录 PHP backtrace 信息，可以使用 ptrace或者类似工具读取和分析远程进程的运行数据)运行所导致的异常缓慢 
7. fastcgi_finish_request() - 特殊功能：用于在请求完成和刷新数据后，继续在后台执行耗时的工作(录入视频转换、统计处理等)
8. 动态／静态子进程产生 
9. 基本 SAPI 运行状态信息(类似Apache的 mod_status)
10. 基于 php.ini 的配置文件 

http://huoding.com/2014/12/25/398
http://php-fpm.org/
http://php.net/manual/zh/install.fpm.php
http://wenku.baidu.com/view/887de969561252d380eb6e92.html
http://baike.baidu.com/view/4168033.htm

<?php
class Config extends Threaded
{   // shared global object
    protected $val = 0, $val2 = 0;
    protected function inc(){++$this->val;}    // protected synchronizes by-object
    public function inc2(){++$this->val2;}    // no synchronization
}
class WorkerClass extends Worker
{
    protected static $worker_id_next = -1;
    protected $worker_id;
    protected $config;
    public function __construct($config)
    {
        $this->worker_id = ++static::$worker_id_next;    // static members are not avalable in thread but are in ‘main thread‘
        $this->config = $config;
    }
    public function run()
    {
        global $config;
        $config = $this->config;    // NOTE: setting by reference WON‘T work
        global $worker_id;
        $worker_id = $this->worker_id;
        echo "working context {$worker_id} is created!\n";
        //$this->say_config();    // globally synchronized function.
    }
    protected function say_config()
    {    // ‘protected‘ is synchronized by-object so WON‘T work between multiple instances
        global $config;        // you can use the shared $config object as synchronization source.
        $config->synchronized(function() use (&$config)
        {    // NOTE: you can use Closures here, but if you attach a Closure to a Threaded object it will be destroyed as can‘t be serialized
            var_dump($config);
        });
    }
}
class Task extends Stackable
{    
    // Stackable still exists, it‘s just somehow dissappeared from docs (probably by mistake). See older version‘s docs for more details.
    protected $set;
    public function __construct($set)
    {
        $this->set = $set;
    }
    public function run()
    {
        global $worker_id;
        echo "task is running in {$worker_id}!\n";
        usleep(mt_rand(1,100)*100);
        $config = $this->getConfig();
        $val = $config->arr->shift();
        $config->arr[] = $this->set;
        for ($i = 0 ; $i < 1000; ++$i)
        {
            $config->inc();
            $config->inc2();
        }
    }
    public function getConfig(){
        global $config;    // WorkerClass set this on thread‘s scope, can be reused by Tasks for additional asynch data source. (ie: connection pool or taskqueue to demultiplexer)
        return $config;
    }
}

$config = new Config;
$config->arr = new Threaded();
$config->arr->merge(array(1,2,3,4,5,6));

class PoolClass extends Pool
{
    public function worker_list()
    {
        if ($this->workers !== null)
            return array_keys($this->workers);
        return null;
    }
}
$pool = new PoolClass(3, ‘WorkerClass‘, [$config] );
$pool->worker_list();
//$pool->submitTo(0,new Task(-10));    // submitTo DOES NOT try to create worker

$spammed_id = -1;
for ($i = 1; $i <= 100; ++$i)
{        
    // add some jobs
    if ($spammed_id == -1 && ($x = $pool->worker_list())!= null && @$x[2])
    {
        $spammed_id = $x[2];
        echo "spamming worker {$spammed_id} with lots of tasks from now on\n";
    }
    if ($spammed_id != -1 && ($i % 5) == 0)    // every 5th job is routed to one worker, so it has 20% of the total jobs (with 3 workers it should do ~33%, not it has (33+20)%, so only delegate to worker if you plan to do balancing as well... )
        $pool->submitTo($spammed_id,new Task(10*$i));    
    else
        $pool->submit(new Task(10*$i));
}
$pool->shutdown();
var_dump($config); // "val" is exactly 100000, "val2" is probably a bit less
// also: if you disable the spammer, you‘ll that the order of the "arr" is random.
     
?>  

http://php.net/manual/zh/class.pool.php
http://netkiller.github.io/journal/thread.php.html

1. TCP：通过TCP连接的方式向PHP解释器发送解析请求
2. Unix Socket：通过Unix Socket方式向PHP解释器发送解析请求

https://blog.linuxeye.com/364.html
http://www.cnxct.com/default-configuration-and-performance-of-nginx-phpfpm-and-tcp-socket-or-unix-domain-socket/

1. 动态模式
一般先启动少量进程，再按照请求数的多少实时调整进程数。如此的优点很明显：节省资源；当然它的缺点也很明显：一旦出现高并发请求，系统将不得不忙着 FORK 新进程，必然会影响性能
2. 静态模式
一次性 FORK 足量的进程，之后不管请求量如何均保持不变。和动态模式相比，静态模式虽然消耗了更多的资源，但是面对高并发请求，它不需要执行高昂的 FORK 

http://www.guangla.com/post/2014-03-14/40061238121
http://forum.nginx.org/read.php?3,222702