php模拟并发

原文： http://blog.csdn.net/zhang_xinglong/article/details/16339867

-------------------------------------------------------------------------------------------------------------------------------

并发请求理论描述：假设有一个client，程序逻辑是要请求三个不同的server，处理各自的响应。传统模型当然是顺序执行，先发送第一个请求，等待收到响应数据后再发送第二个请求，以此类推。就像是单核CPU，一次只能处理一件事，其他事情被暂时阻塞。而并发模式可以让三个server同时处理各自请求，这就可以使大量时间复用。

画个图更好说明问题：

前者为阻塞模式，忽略请求响应等时间，总耗时为700ms；而后者非阻塞模式，由于三个请求可以同时得到处理，总耗时只有300ms。所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回。所谓非阻塞方式non-block，就是进程或线程执行此函数时不必非要等待事件的发生，一旦执行肯定返回，以返回值的不同来反映函数的执行情况，如果事件发生则与阻塞方式相同，若事件没有发生则返回一个代码来告知事件未发生，而进程或线程继续执行，所以效率较高。

PHP本身是不支持多线程的，但是它可以利用Linux和apache的多线程能力。php模拟的多线程其实只是多进程，并不是真正的多线程。以下是几种php模拟多线程的方法：
1.php+shell (利用linux os)

php代码(test.php)：

<?php
for($i = 0; $i < 10; $i++)
{
echo $i;
sleep(5); //这里为了方便看效果sleep一下让脚本执行时间更长
}
?>

shell代码(test.sh)：

#!/bin/bash
for i in 1 2 3 4 5
do
/usr/bin/php -r -q test.php &
done

注意：
在请求php代码的那行末尾有一个&符号，这个是关键，不加的话是不能进行多线程的，&表示将服务推送到后台执行，因此在shell的每次的循环中不必等php的代码全部执行完在请求下一个文件，而是同时进行的，这样就实现了多线程，下面运行下shell看下效果，这里你将看到5个test.php进程，再利用linux的定时器，定时请求这个shell，在处理一些需要多线程的任务，例如，批量下载时，非常好用！
参考：http://blog.csdn.net/tianmohust/article/details/8208627

2.php+pcntl(利用linux os)
只能用在Unix Like OS，Windows不可用。且推荐仅仅在CLI模式运行，不要在WEB服务器环境运行。

<?php
declare(ticks=1);
//是否等待进程结束
$bWaitFlag = FALSE;
//进程总数
$intNum = 10;
//进程PID数组
$pids = array();
echo ("Start\n");
for($i = 0; $i < $intNum; $i++)
{
//产生子进程，而且从当前行之下开试运行代码，而且不继承父进程的数据信息
$pids[$i] = pcntl_fork();
if( ! $pids[$i])
{
//子进程进程代码段_Start
$str = "";
sleep(5+$i);
for ($j = 0; $j < $i; $j++)
{
$str .= "*";
}
echo "$i -> " . time() . " $str \n";
exit();
//子进程进程代码段_End
}
}
if ($bWaitFlag)
{
for($i = 0; $i < $intNum; $i++)
{
pcntl_waitpid($pids[$i], $status, WUNTRACED);
echo "wait $i -> " . time() . "\n";
}
}
echo ("End\n");
?>

运行结果如下：

[qiao@oicq qiao]$ php test.php
Start
End
[qiao@oicq qiao]$ ps -aux | grep "php"
qiao 32275 0.0 0.5 49668 6148 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32276 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32277 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32278 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32279 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32280 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32281 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32282 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32283 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32284 0.0 0.5 49668 6152 pts/1 S 14:03 0:00 /usr/local/php4/b
qiao 32286 0.0 0.0 1620 600 pts/1 S 14:03 0:00 grep php
[qiao@oicq qiao]$ 0 -> 1133503401
1 -> 1133503402 *
2 -> 1133503403 **
3 -> 1133503404 ***
4 -> 1133503405 ****
5 -> 1133503406 *****
6 -> 1133503407 ******
7 -> 1133503408 *******
8 -> 1133503409 ********
9 -> 1133503410 *********
[qiao@oicq qiao]$

如果$bWaitFlag=TURE，则结果如下：

[qiao@oicq qiao]$ php test.php
Start
0 -> 1133503602
wait 0 -> 1133503602
1 -> 1133503603 *
wait 1 -> 1133503603
2 -> 1133503604 **
wait 2 -> 1133503604
3 -> 1133503605 ***
wait 3 -> 1133503605
4 -> 1133503606 ****
wait 4 -> 1133503606
5 -> 1133503607 *****
wait 5 -> 1133503607
6 -> 1133503608 ******
wait 6 -> 1133503608
7 -> 1133503609 *******
wait 7 -> 1133503609
8 -> 1133503610 ********
wait 8 -> 1133503610
9 -> 1133503611 *********
wait 9 -> 1133503611
End
[qiao@oicq qiao]$

从多进程的例子可以看出，使用pcntl_fork()之后，将生成一个子进程，而且子进程运行的代码，从pcntl_fork()之后的代码开始，而子进程不继承父进程的数据信息(实际上是把父进程的数据做了一个全新的拷贝)，因而使用if(!$pids[$i]) 来控制子进程实际运行的代码段。
参考：http://hi.baidu.com/tangyubinsir/item/43c04f85ea7709d4d1f8cd84和http://www.itlearner.com/article/4908
3.php+pthreads
参考：http://blog.csdn.net/leinchu/article/details/11795985
4.php+socket(利用web server)
假设你要建立一个服务来检查正在运行的n台服务器，以确定他们还在正常运转。你可能会写下面这样的代码：

<?php
$hosts = array("www.baidu.com", "www.sohu.com", "www.163.com");
$timeout = 15;
$status = array();
foreach ($hosts as $host)
{
$errno = 0;
$errstr = "";
$s = fsockopen($host, 80, $errno, $errstr, $timeout);
if ($s)
{
$status[$host] = "Connected\n";
fwrite($s, "HEAD / HTTP/1.0\r\nHost: $host\r\n\r\n"); //第二个参数是HTTP协议中规定的请求头，不明白的请看RFC中的定义
do
{
$data = fread($s, 8192);
if (strlen($data) == 0)
{
break;
}
$status[$host] .= $data; //返回连接状态
}
while (true);
fclose($s);
}
else
{
$status[$host] = "Connection failed: $errno $errstrn";
}
}
echo '<pre>';
print_r($status);
?>

它运行的很好，但是在fsockopen()分析完hostname并且建立一个成功的连接（或者延时$timeout秒）之前，扩充这段代码来管理大量服务器将耗费很长时间。
因此我们必须放弃这段代码；我们可以建立异步连接-不需要等待fsockopen返回连接状态。PHP仍然需要解析hostname（所以直接使用ip更加明智），不过将在打开一个连接之后立刻返回，继而我们就可以连接下一台服务器。
有两种方法可以实现；PHP5中可以使用新增的stream_socket_client()函数直接替换掉fsocketopen()。PHP5之前的版本，你需要自己动手，用sockets扩展解决问题。
下面是PHP5中的解决方法：

<?php
$hosts = array("www.baidu.com", "www.sohu.com", "www.163.com");
$timeout = 15;
$status = array();
$sockets = array();
/* Initiate connections to all the hosts simultaneously */
foreach ($hosts as $id => $host)
{
$s = stream_socket_client(
"$host:80", $errno, $errstr, $timeout,
TREAM_CLIENT_ASYNC_CONNECT|STREAM_CLIENT_CONNECT);
/* 这里需要稍微延迟一下，否则下面fwrite中的socket句柄不一定能真正使用
* 这里应该是PHP的一处bug，查了一下，官方bug早在08年就有人提交了
* 我的5.2.8中尚未解决，不知最新的5.3中是否修正
*/
usleep(10);
if ($s)
{
$sockets[$id] = $s;
$status[$hosts[$id]] = "in progress";
}
else
{
$status[$hosts[$id]] = "failed, $errno $errstr";
}
}
/* Now, wait for the results to come back in */
while (count($sockets))
{
$read = $write = $sockets;
// $e = null;
/* This is the magic function - explained below */
$n = stream_select($read, $write, $e, $timeout);
if ($n > 0) //据说stream_select返回值不总是可信任的
// if (count($read))
{
/* readable sockets either have data for us, or are failed connection attempts */
foreach ($read as $r)
{
/* stream_select generally shuffles $read, so we need to
compute from which socket(s) we're reading. */
$id = array_search($r, $sockets);
$data = fread($r, 8192);
/* A socket is readable either because it has
data to read, OR because it's at EOF. */
if (strlen($data) == 0)
{
if ($status[$hosts[$id]] == "in progress")
{
$status[$hosts[$id]] = "failed to connect";
}
fclose($r);
unset($sockets[$id]);
}
else
{
$status[$hosts[$id]] = $data;
}
}
/* writeable sockets can accept an HTTP request */
foreach ($write as $w)
{
$id = array_search($w, $sockets);
if(is_resource($w) && feof($w) === FALSE)
{
@fwrite($w, "HEAD / HTTP/1.0\r\nHost: " . $hosts[$id] . "\r\n\r\n");
// $flag && $status[$hosts[$id]] = "waiting for response";
}
}
}
else
{
/* timed out waiting; assume that all hosts associated with $sockets are faulty */
foreach ($sockets as $id => $s)
{
$status[$hosts[$id]] = "timed out " . $status[$hosts[$id]];
}
break;
}
}
echo '<pre>';var_dump($status);
?>

我们用stream_select()等待sockets打开的连接事件。stream_select()调用系统的select()函数来工作：前面三个参数是你要使用的streams的数组；你可以对其读取，写入和获取异常（分别针对三个参数）。stream_select()可以通过设置$timeout（秒）参数来等待事件发生-事件发生时，相应的sockets数据将写入你传入的参数。
下面是PHP4.1.0之后版本的实现，如果你已经在编译PHP时包含了sockets(ext/sockets)支持，你可以使用根上面类似的代码，只是需要将上面的streams/filesystem函数的功能用ext/sockets函数实现。主要的不同在于我们用下面的函数代替 stream_socket_client()来建立连接：

<?php
// This value is correct for Linux, other systems have other values
define('EINPROGRESS', 115);
function non_blocking_connect($host, $port, &$errno, &$errstr, $timeout) {
$ip = gethostbyname($host);
$s = socket_create(AF_INET, SOCK_STREAM, 0);
if (socket_set_nonblock($s)) {
$r = @socket_connect($s, $ip, $port);
if ($r || socket_last_error() == EINPROGRESS) {
$errno = EINPROGRESS;
return $s;
}
}
$errno = socket_last_error($s);
$errstr = socket_strerror($errno);
socket_close($s);
return false;
}
?>

现在用socket_select()替换掉stream_select()，用socket_read()替换掉fread()，用socket_write()替换掉fwrite()，用socket_close()替换掉fclose()就可以执行脚本了！ PHP5的先进之处在于，你可以用stream_select()处理几乎所有的stream。例如你可以通过include STDIN用它接收键盘输入并保存进数组，你还可以接收通过proc_open()打开的管道中的数据。
注：select在socket编程中还是比较重要的，可是对于初学socket的人来说都不太爱用select写程序，他们只是习惯写诸如connect、 accept、recv或recvfrom这样的阻塞程序。可是使用select就可以完成非阻塞方式工作的程序，它能够监视我们需要监视的文件描述符的变化情况——读写或是异常。
参考：http://blog.csdn.net/21aspnet/article/details/7420024
5.php+curl
（1）经典curl并发机制和存在问题
经典的cURL实现机制在网上很容易找到, 比如参考PHP在线手册的如下实现方式:

<?php
function classic_curl($urls, $delay) {
$queue = curl_multi_init();
$map = array();
foreach ($urls as $url) {
// create cURL resources
$ch = curl_init();
// set URL and other appropriate options
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_TIMEOUT, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_NOSIGNAL, true);
// add handle
curl_multi_add_handle($queue, $ch);
$map[$url] = $ch;
}
$active = null;
// execute the handles
do {
$mrc = curl_multi_exec($queue, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
while ($active > 0 && $mrc == CURLM_OK) {
if (curl_multi_select($queue, 0.5) != -1) {
do {
$mrc = curl_multi_exec($queue, $active);
} while ($mrc == CURLM_CALL_MULTI_PERFORM);
}
}
$responses = array();
foreach ($map as $url=>$ch) {
$responses[$url] = callback(curl_multi_getcontent($ch), $delay);
curl_multi_remove_handle($queue, $ch);
curl_close($ch);
}
curl_multi_close($queue);
return $responses;
}
?>

首先将所有的URL压入并发队列, 然后执行并发过程, 等待所有请求接收完之后进行数据的解析等后续处理. 在实际的处理过程中, 受网络传输的影响, 部分URL的内容会优先于其他URL返回, 但是经典cURL并发必须等待最慢的那个URL返回之后才开始处理, 等待也就意味着CPU的空闲和浪费. 如果URL队列很短, 这种空闲和浪费还处在可接受的范围, 但如果队列很长, 这种等待和浪费将变得不可接受.
（2）改进的rolling curl并发方式
仔细分析不难发现经典cURL并发还存在优化的空间, 优化的方式时当某个URL请求完毕之后尽可能快的去处理它, 边处理边等待其他的URL返回, 而不是等待那个最慢的接口返回之后才开始处理等工作, 从而避免CPU的空闲和浪费. 闲话不多说, 下面贴上具体的实现:

<?php
function rolling_curl($urls, $delay) {
$queue = curl_multi_init();
$map = array();
foreach ($urls as $url) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_TIMEOUT, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_NOSIGNAL, true);
curl_multi_add_handle($queue, $ch);
$map[(string) $ch] = $url;
}
$responses = array();
do {
while (($code = curl_multi_exec($queue, $active)) == CURLM_CALL_MULTI_PERFORM) ;
if ($code != CURLM_OK) { break; }
// a request was just completed -- find out which one
while ($done = curl_multi_info_read($queue)) {
// get the info and content returned on the request
$info = curl_getinfo($done['handle']);
$error = curl_error($done['handle']);
$results = callback(curl_multi_getcontent($done['handle']), $delay);
$responses[$map[(string) $done['handle']]] = compact('info', 'error', 'results');
// remove the curl handle that just completed
curl_multi_remove_handle($queue, $done['handle']);
curl_close($done['handle']);
}
// Block for data in / output; error handling is done by curl_multi_exec
if ($active > 0) {
curl_multi_select($queue, 0.5);
}
} while ($active);
curl_multi_close($queue);
return $responses;
}
?>

（3）两种并发实现的性能对比
性能测试中用到的回调函数为:

function callback($data, $delay) {
preg_match_all('/<h3>(.+)<\/h3>/iU', $data, $matches);
usleep($delay);
return compact('data', 'matches');
}

数据处理回调无延迟时: Rolling Curl略优, 但性能提升效果不明显.数据处理回调延迟5毫秒: Rolling Curl完胜, 性能提升40%左右.通过上面的性能对比, 在处理URL队列并发的应用场景中Rolling cURL应该是更加的选择, 并发量非常大(1000+)时, 可以控制并发队列的最大长度, 比如20, 每当1个URL返回并处理完毕之后立即加入1个尚未请求的URL到队列中, 这样写出来的代码会更加健壮, 不至于并发数太大而卡死或崩溃.

巴特西

php模拟并发

最新文章

热门文章