• 简单的PHP的任务队列


    文章太长,不作过多介绍,反正,文章的头部就说明了大概的意思。。。
    原文如下:
    写了一个简单的队列任务处理。多进程任务,异步任务可能会用到这个(主要是命令行应用)
    比如,任务的某个一个环节速度十分不稳定,可能执行几秒,也可能执行几分钟,
    我就可以把那个环节包括前面的部分扔进队列,多跑几个进程,同时往队列里面写。
    然后后面比较快的环节只跑一个处理任务就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 ";  
    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." ";  
    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. ?>  
  • 相关阅读:
    30行js让你的rem弹性布局适配所有分辨率(含竖屏适配)(转载)
    JavaScript事件流原理解析
    Java中this和super的用法和区别
    Java多态面试题案例几解题思路
    Java多态的向上转型和向下转型
    Java方法的重载和重写
    Java冒泡具体的原理,以及下标的变化
    Java中的冒泡排序和选择排序
    使用Java实现对一个数组的增删改查以及初始化
    Java中构造函数传参数在基本数据类型和引用类型之间的区别
  • 原文地址:https://www.cnblogs.com/jshen/p/4167088.html
Copyright © 2020-2023  润新知