PHP作为解释器运行通过线程或者进程都能实现（如果使用Apache，那么就可能使用多线程模型。使用php-fpm，就是使用多进程模型，这里以多进程模型解释）。服务器每接收到一个请求就要起一个PHP进程，平均一个PHP进程消耗内存2M左右（默认最大为8M，参数可以设置）。独立的进程让PHP能专一的做自己的解释工作，程序员也从复杂的代码逻辑中走出来，不用担心资源的竞争和各种锁问题。独立进程虽好但这也导致想通过多进程或者异步来提速成本非常的高（主要是开发难度）。如果一定要通过PHP实现多进程和异步其实是很容易做到的。

PHP有很多第三方扩展，比如Swoole能让PHP像Node一样实现异步。PHP官方扩展库pcntl_*能很简单的实现多进程。扩展虽好，但实际应用时切忌要慎重，便利的同时风险也来了。比如对多进程的控制，处理不好很容易导致程序死锁，CPU内存爆表、服务器宕机。异步回调的Coding方式与PHP本身的编程思想有一定出入，驾驭不好也是灾难。

当然也不能说的太吓人，在实际的项目中我们有很多场景不得不考虑通过多进程或者异步来优化程序。这里举一个很常见的例子『发送消息通知』，比如短信和邮件。这里说一个实际的场景：企业需要给200W用户发短信通知，短信接口支持最大100次/秒的调用频率，短信接口每次调用耗时300毫秒。如果单进程跑脚本的话，需要7天才能把短信发完。如果我们起30个进程，每秒能发送100条短信，6个小时内能发完，能提速30倍。优化方案确定之后，我们再看如何通过PHP去实现这样一个脚本。

一. pcntl扩展初探；
通过pcntl扩展创建多进程,参见如下代码；

  1.     function demo(array $phoneList){
  2.         $cnt = count($phoneList);  //测试数组大小
  3.         $slice = 30;  //需要调用的进程数量
  4.         $master = array_chunk($phoneList,floor($cnt/$slice));
  5.         $childList = [];
  7.         while($slice >= 0)
  8.         {
  9.             $pid = pcntl_fork();
  10.             if($pid > 0){
  11.                 $childList[$pid] = 1;
  12.                 //$pid>0表示当前还在执行父进程的代码
  13.                 //这里最好啥都不做，每次执行pcntl_fork都会执行这里的代码。
  14.                 //这里的代码执行完之后 会将$pid设置为0，然后jump到pcntl_fork代码之后，重新做判断；
  15.             }elseif($pid == 0){
  16.                 //这里写我们的逻辑
  17.                 foreach($master[$slice] as $val)
  18.                 {
  19.                     //这里发生短信
  20.                     echo sprintf("%s Child:%s  \r\n",$slice,$val);
  21.                 }
  22.                 //子进程执行完之后务必需要关闭;
  23.                 exit();
  24.             }else
  25.             {
  26.                 //程序发生错误也需要关闭程序
  27.                 exit();
  28.             }
  29.             $slice--;
  30.         }
  32.         // 等待所有子进程结束后回收资源
  33.         while(!empty($childList)){
  34.             $childPid = pcntl_wait($status);
  35.             if ($childPid > 0){
  36.                 unset($childList[$childPid]);
  37.             }
  38.         }
  39.     }
  41. /** 运行的结果如下，phone不是连续的
  42. Slice id:19,phone:66558 
  43. Slice id:23,phone:79921 
  44. Slice id:19,phone:66559 
  45. Slice id:23,phone:79922 
  46. Slice id:19,phone:66560 
  47. Slice id:23,phone:79923 
  48. Slice id:19,phone:66561 
  49. Slice id:23,phone:79924 
  50. Slice id:19,phone:66562 
  51. Slice id:23,phone:79925 
  52. **/

通过pcntl扩展，几句代码就使用多进程将发消息通知的功能提速了30倍。不过这么简单的多进程编码，我为什么会在文章开始形容的如此复杂呢？

重点和难点还是进程间通信，因为我们给用户发短信的每个子进程是相对独立的，进程之间没有通信，不会互相传递数据状态。所以不会发生资源抢占与锁问题。假如需求发生变化，我们需要按用户的活跃度高低给用户发短信，该怎么做？

通俗点解释如下：一个盘子里有30个苹果，需要发给30个人，由3个人负责发苹果。最简单的办法就是我们先把苹果分成3份，3个人一人一份，很快就能发完。但是如果我们要按照苹果的大小顺序去发，把大苹果先发出去，此时我们就没办法分成3份了，只能三个人互相去挣当前最大的，很容易就打起来。那该怎么做呢？最常见的办法就是使用一个工具把所有苹果按由大到下的顺序放在里面，每次只能取一个，这样就解决了资源抢占的问题。

关于进程间资源抢占的问题非常的复杂，编码难度非常高，这也是为什么很少使用PHP跑多进程的原因。当需要用到多进程时我们更愿意去使用Python或者Java，它们对多线程封装的更好。需要重点说的是PHP并不是不能写多进程的程序，也不是像其他人说的不稳定，而是编码费时，维护成本高。

二. 进程间通信
常见的进程通信方式有：消息队列、共享内存与信号量、管道、socket，我将一一举例说明。

消息队列
『消息队列』是在消息的传输过程中保存消息的容器。消息队列管理器相当于消息发送者和接收者的中介。消息队列的主要目的是创建路由并且保证消息可靠传递；如果发送消息时接收者不可用，消息队列会保留消息，直到有人接收它。

消息队列可提供临时存储的功能并且能保证消息可靠的传递，我们正好使用它实现进程间通信。当然消息队列不单单用于进程间通信，他的应用领域非常广。比如消息队列非常适用于解决消费者和生产者的问题，因为生产者和消费者之间总会存在『速度差』。比如生产者突然少了10个，两边处理的速度就会不平衡，会导致排队阻塞，服务不可用。这肯定不是我们想看到的，如果这时候引入消息队列将两个系统解耦，无论谁慢了都不会影响整体业务。

  1. function demo(array $phoneList){
  2.     global $msgQueue;
  3.     $cnt = count($phoneList);  //测试数组大小
  4.     $slice = 3;  //需要调用的进程数量
  5.     $childList = [];
  6.     //主进程先发送一条消息，告诉子进程可以发送第一条短信了
  7.     msg_send($msgQueue,MSG_TYPE,0);
  9.     while($slice >= 0)
  10.     {
  11.         $pid = pcntl_fork();
  12.         if($pid > 0){
  13.             $childList[$pid] = 1;
  14.             //父进程什么都不用做
  16.         }elseif($pid == 0){
  17.             //子进程不停的请求，直到所有短信发送完成
  18.             while(msg_receive($msgQueue,MSG_TYPE,$msgType,1024,$message))
  19.             {
  20.                 if($cnt>intval($message))
  21.                 {
  22.                     printf("Slice id:%s,phone:%s \r\n",$slice,$phoneList[$message]);
  23.                     $message = $message + 1;
  24.                     msg_send($msgQueue,MSG_TYPE,$message);
  25.                 }else
  26.                 {
  27.                     //通知其他进程一切都结束了
  28.                     msg_send($msgQueue,MSG_TYPE,$cnt);
  29.                     exit();
  30.                 }
  31.             }
  32.         }else
  33.         {
  34.             //程序发生错误也需要关闭程序
  35.             exit();
  36.         }
  37.         $slice--;
  38.     }
  40.     // 等待所有子进程结束后回收资源
  41.     while(!empty($childList)){
  42.         $childPid = pcntl_wait($status);
  43.         if ($childPid > 0){
  44.             unset($childList[$childPid]);
  45.         }
  46.     }
  47. }
  49. const MSG_TYPE = 1;
  50. //创建消息队列
  51. $id = ftok(__FILE__,'m');
  52. $msgQueue = msg_get_queue($id);
  54. demo(range(0,900));
  56. /**运行结果，按大小输出
  57. Slice id:1,phone:895 
  58. Slice id:1,phone:896 
  59. Slice id:2,phone:897 
  60. Slice id:3,phone:898 
  61. Slice id:3,phone:899 
  62. **/

共享内存与信号量
『共享内存』很容易理解，就是在内存中找一块区域，所有进程都能读写。『信号量』是系统提供的一种原子操作，进程在开启信号和结束信号之间拥有共享内存的『绝对占有』权，这样能有效的防止多个进程读取同一个资源时发生死锁。

  1.     function demo(array $phoneList){
  2.         global $shareMemory;
  3.         global $signal;
  4.         $cnt = count($phoneList);  //测试数组大小
  5.         $slice = 3;  //需要调用的进程数量
  6.         $childList = [];
  8.         while($slice >= 0)
  9.         {
  10.             $pid = pcntl_fork();
  11.             if($pid > 0){
  12.                 $childList[$pid] = 1;
  13.                 //父进程什么都不用做
  15.             }elseif($pid == 0){
  17.                 while(true)
  18.                 {
  19.                     // 标记信号量,这里被我承包了
  20.                     sem_acquire($signal);
  21.                     //检测共享内存是否存在
  22.                     if (shm_has_var($shareMemory,SHARE_KEY)){
  23.                         //从共享内存中拿数据
  24.                         $val = shm_get_var($shareMemory,SHARE_KEY);
  25.                         if($val>=$cnt)
  26.                         {
  27.                             sem_release($signal);
  28.                             break;
  29.                         }else
  30.                         {
  31.                             printf("Slice id:%s,phone:%s \r\n",$slice,$phoneList[$val]);
  32.                             $val ++;
  33.                             //再将数据写入共享内存
  34.                             shm_put_var($shareMemory,SHARE_KEY,$val);
  35.                         }
  36.                     }else{
  37.                         // 无值会,先初始化
  38.                         shm_put_var($shareMemory,SHARE_KEY,0);
  39.                     }
  40.                     // 用完释放
  41.                     sem_release($signal);
  42.                 }
  43.                 exit();
  44.             }else
  45.             {
  46.                 //程序发生错误也需要关闭程序
  47.                 exit();
  48.             }
  49.             $slice--;
  50.         }
  52.         // 等待所有子进程结束后回收资源
  53.         while(!empty($childList)){
  54.             $childPid = pcntl_wait($status);
  55.             if ($childPid > 0){
  56.                 unset($childList[$childPid]);
  57.             }
  58.         }
  59.     }
  61.     const SHARE_KEY = 1;
  63.     // 创建一块共享内存
  64.     $shm_id = ftok(__FILE__,'a');
  65.     $shareMemory = shm_attach($shm_id);
  67.     // 创建一个信号量
  68.     $sem_id = ftok(__FILE__,'b');
  69.     $signal = sem_get($sem_id);
  71.     demo(range(0,900));
  73.     // 释放共享内存与信号量
  74.     shm_remove($shareMemory);
  75.     sem_remove($signal);
  77. /**运行结果，按大小输出
  78. Slice id:1,phone:775 
  79. Slice id:3,phone:776 
  80. Slice id:3,phone:777 
  81. Slice id:3,phone:778 
  82. Slice id:0,phone:779 
  83. Slice id:0,phone:780 
  84. **/

管道
管道是比较常用的进程间通信手段，管道又分为匿名管道(pipe)与具名管道(mkfifo)，匿名管道只能用于具有亲缘关系的进程间通信，而具名管道可以用于同一主机上任意进程。

pipe与mkfifo的主要差别是mkfifo会创建一个特殊的FIFO物理文件，这个FIFO文件其他进程都可以像读写一般文件一样读写。


赏
相关评论(0)
您是不是忘了说点什么？

友情提示：垃圾评论一律封号...

还没有评论，快来抢沙发吧！