首页 > 代码库 > 简单的PHP的任务队列

简单的PHP的任务队列

2024-08-08 06:26:02   228人阅读

文章太长，不作过多介绍，反正，文章的头部就说明了大概的意思。。。
原文如下：
写了一个简单的队列任务处理。多进程任务，异步任务可能会用到这个(主要是命令行应用)
比如，任务的某个一个环节速度十分不稳定，可能执行几秒，也可能执行几分钟，
我就可以把那个环节包括前面的部分扔进队列，多跑几个进程，同时往队列里面写。
然后后面比较快的环节只跑一个处理任务就OK了。让整体速度达到更好的效果。

write.php: 将任务写入队列

PHP代码
  1. <?php  
  2. /* 
  3. 产生队列 
  4. */  
  5. //用微秒生成队列文件名。因为会有多个队列，所以加了一个identifier来区分各个队列  
  6. function mt($identifier=‘default‘)  
  7. {  
  8.         return sprintf("%.6f.%s",strtok(microtime(),‘ ‘)+strtok(‘‘),$identifier);  
  9. }  
  10.   
  11. while(1) //实际中尽量不要while(1) 非要while(1)记得任务完成要break  
  12. {  
  13.         if(count(glob(‘./queue/*.identifier‘))>=10) //队列最大长度，不限制的话硬盘可能会受不了哦。  
  14.         {  
  15.                 sleep(1);//记住这里要sleep,否则队列满了cpu占用很高  
  16.                 continue;  
  17.         }  
  18.         $url = ‘www.‘.time().‘.com‘; //随便举个例子，我用时间戳生成了一个网址  
  19.         echo "$url\r\n";  
  20.         $fp = fopen(‘./queue/‘.mt(‘identifier‘),‘w‘);  
  21.         fwrite($fp,$url);  
  22.         fclose($fp);  
  23.         sleep(1);//这里不需要sleep，我sleep是因为我的任务太简单。  
  24. }  
  25. ?>  

read.php:

PHP代码
  1. <?php  
  2. /* 
  3. 处理队列 
  4. */  
  5.   
  6. while(1) //实际程序最好不要while(1)如果while(1)，记得处理完任务要break  
  7. {  
  8.         if($queue = glob(‘./queue/*.identifier‘))  
  9.         {  
  10.                 $q = array_shift($queue);  
  11.                 $url = file_get_contents($q);  
  12.                 echo $url."\r\n";  
  13.                 unlink($q);  
  14.         }  
  15.         sleep(1);//这里要不要sleep或sleep多久自己凭感觉来。  
  16. }  
  17. ?>  

相关的资料：双向队列

baidu和google上没有查到PHP双向队列的资料，搜索到java的双向队列定义如下：双向队列（双端队列）就像是一个队列，但是你可以在任何一端添加或移除元素。
而双端队列是一种数据结构，定义如下：
A deque is a data structure consisting of a list of items, on which the following operations are possible.
* push(D,X) -- insert item X on the rear end of deque D.
* pop(D) -- remove the front item from the deque D and return it.
* inject(D,X) -- insert item X on the front end of deque D.
* eject(D) -- remove the rear item from the deque D and return it.
Write routines to support the deque that take O(1) time per operation.

翻译：双端队列（deque）是由一些项的表组成的数据结构，对该数据结构可以进行下列操作：
push(D,X) 将项X 插入到双端队列D的前端
pop(D) 从双端队列D中删除前端项并将其返回
inject(D,X) 将项X插入到双端队列D的尾端
eject(D) 从双端队列D中删除尾端项并将其返回
编写支持双端队伍的例程，每种操作均花费O（1）时间

百度百科：（deque，全名double-ended queue）是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。

转贴一个使用Php数组函数实现该功能的代码：

PHP代码
  1. <?php  
  2. //Input limit double-ende queue  
  3. class DoubleEndedQueue1 {  
  4. var $queue = array();  
  5. function add($var){  
  6.     return array_push($this->queue, $var);  
  7. }  
  8. function frontRemove(){  
  9.     return array_shift($this->queue);  
  10. }  
  11. function rearRemove(){  
  12.     return array_pop($this->queue);  
  13. }  
  14. }  
  15.   
  16. //Output limit double-ende queue  
  17. class DoubleEndedQueue2 {  
  18. var $queue = array();  
  19. function remove(){  
  20.     return array_pop($this->queue);  
  21. }  
  22. function frontAdd($var){  
  23.     return array_unshift($this->queue, $var);  
  24. }  
  25. function rearAdd($var){  
  26.     return array_push($this->queue, $var);  
  27. }  
  28. }  
  29.   
  30. //Test code  
  31. $q = new DoubleEndedQueue1;  
  32. $q->add(‘aaa‘);  
  33. $q->add(‘bbb‘);  
  34. $q->add(‘ccc‘);  
  35. $q->add(‘ddd‘);  
  36.   
  37. echo $q->frontRemove();  
  38. echo "<br>";  
  39. echo $q->rearRemove();  
  40. echo "<br>";  
  41. print_r($q->queue);  
  42. ?>  

array_push -- 将一个或多个单元压入数组的末尾（入栈）
array_unshift -- 在数组开头插入一个或多个单元
array_pop -- 将数组最后一个单元弹出（出栈）
array_shift -- 将数组开头的单元移出数组

// 来自 PHP5 in Practice  (U.S.)Elliott III & Jonathan D.Eisenhamer

PHP代码
    1. <?php  
    2. // A library to implement queues in PHP via arrays  
    3. // The Initialize function creates a new queue:  
    4. function &queue_initialize() {  
    5.     // In this case, just return a new array  
    6.     $new = array();  
    7.     return $new;  
    8. }  
    9. // The destroy function will get rid of a queue  
    10. function queue_destroy(&$queue) {  
    11.     // Since PHP is nice to us, we can just use unset  
    12.     unset($queue);  
    13. }  
    14. // The enqueue operation adds a new value unto the back of the queue  
    15. function queue_enqueue(&$queue, $value) {  
    16.     // We are just adding a value to the end of the array, so can use the  
    17.     //  [] PHP Shortcut for this.  It‘s faster than using array_push  
    18.     $queue[] = $value;  
    19. }  
    20. // Dequeue removes the front of the queue and returns it to you  
    21. function queue_dequeue(&$queue) {  
    22.     // Just use array unshift  
    23.     return array_shift($queue);  
    24. }  
    25. // Peek returns a copy of the front of the queue, leaving it in place  
    26. function queue_peek(&$queue) {  
    27.     // Return a copy of the value found in front of queue  
    28.     //  (at the beginning of the array)  
    29.     return $queue[0];  
    30. }  
    31. // Size returns the number of elements in the queue  
    32. function queue_size(&$queue) {  
    33.     // Just using count will give the proper number:  
    34.     return count($queue);  
    35. }  
    36. // Rotate takes the item on the front and sends it to the back of the queue.  
    37. function queue_rotate(&$queue) {  
    38.     // Remove the first item and insert it at the rear.  
    39.     $queue[] = array_shift($queue);  
    40. }  
    41. // Let‘s use these to create a small queue of data and manipulate it.  
    42. // Start by adding a few words to it:  
    43. $myqueue =& queue_initialize();  
    44. queue_enqueue($myqueue, ‘Opal‘);  
    45. queue_enqueue($myqueue, ‘Dolphin‘);  
    46. queue_enqueue($myqueue, ‘Pelican‘);  
    47. // The queue is: Opal Dolphin Pelican  
    48. // Check the size, it should be 3  
    49. echo ‘<p>Queue size is: ‘, queue_size($myqueue), ‘</p>‘;  
    50. // Peek at the front of the queue, it should be: Opal  
    51. echo ‘<p>Front of the queue is: ‘, queue_peek($myqueue), ‘</p>‘;  
    52. // Now rotate the queue, giving us: Dolphin Pelican Opal  
    53. queue_rotate($myqueue);  
    54. // Remove the front element, returning: Dolphin  
    55. echo ‘<p>Removed the element at the front of the queue: ‘,  
    56.     queue_dequeue($myqueue), ‘</p>‘;  
    57. // Now destroy it, we are done.  
    58. queue_destroy($myqueue);  
    59. ?>  

简单的PHP的任务队列


联系
我们