现在memcache在服务器缓存应用比较广泛，下面我来介绍memcache实现消息队列等待的一个例子，有需要了解的朋友可参考。

memche消息队列的原理就是在key上做文章，用以做一个连续的数字加上前缀记录序列化以后消息或者日志。然后通过定时程序将内容落地到文件或者数据库。

php实现消息队列的用处比如在做发送邮件时发送大量邮件很费时间的问题，那么可以采取队列。

方便实现队列的轻量级队列服务器是：

starling支持memcache协议的轻量级持久化服务器

https://github.com/starling/starling

Beanstalkd轻量、高效，支持持久化，每秒可处理3000左右的队列

http://kr.github.com/beanstalkd/

php中也可以使用memcache/memcached来实现消息队列，代码如下:

1. <?php  
2. /** 
3. * Memcache 消息队列类 
4. */  
5. class QMC {  
6. const PREFIX = 'ASDFASDFFWQKE';  
7. /** 
8. * 初始化mc 
9. * @staticvar string $mc 
10. * @return Memcache 
11. */  
12. static private function mc_init() {  
13. static $mc = null;  
14. if (is_null($mc)) {  
15. $mc = new Memcache;  
16. $mc->connect('127.0.0.1', 11211);  
17. }  
18. return $mc;  
19. }  
20. /** 
21. * mc 计数器,增加计数并返回新的计数 
22. * @param string $key   计数器 
23. * @param int $offset   计数增量,可为负数.0为不改变计数 
24. * @param int $time     时间 
25. * @return int/false    失败是返回false,成功时返回更新计数器后的计数 
26. */  
27. static public function set_counter( $key, $offset, $time=0 ){  
28. $mc = self::mc_init();  
29. $val = $mc->get($key);  
30. if( !is_numeric($val) || $val < 0 ){  
31. $ret = $mc->set( $key, 0, $time );  
32. if( !$ret ) return false;  
33. $val = 0;  
34. }  
35. $offset = intval( $offset );  
36. if( $offset > 0 ){  
37. return $mc->increment( $key, $offset );  
38. }elseif( $offset < 0 ){  
39. return $mc->decrement( $key, -$offset );  
40. }  
41. return $val;  
42. }  
43. /** 
44. * 写入队列 
45. * @param string $key 
46. * @param mixed $value 
47. * @return bool 
48. */  
49. static public function input( $key, $value ){  
50. $mc = self::mc_init();  
51. $w_key = self::PREFIX.$key.'W';  
52. $v_key = self::PREFIX.$key.self::set_counter($w_key, 1);  
53. return $mc->set( $v_key, $value );  
54. }  
55. /** 
56. * 读取队列里的数据 
57. * @param string $key 
58. * @param int $max  最多读取条数 
59. * @return array 
60. */  
61. static public function output( $key, $max=100 ){  
62. $out = array();  
63. $mc = self::mc_init();  
64. $r_key = self::PREFIX.$key.'R';  
65. $w_key = self::PREFIX.$key.'W';  
66. $r_p   = self::set_counter( $r_key, 0 );//读指针  
67. $w_p   = self::set_counter( $w_key, 0 );//写指针  
68. if( $r_p == 0 ) $r_p = 1;  
69. while( $w_p >= $r_p ){  
70. if( --$max < 0 ) break;  
71. $v_key = self::PREFIX.$key.$r_p;  
72. $r_p = self::set_counter( $r_key, 1 );  
73. $out[] = $mc->get( $v_key );  
74. $mc->delete($v_key);  
75. }  
76. return $out;  
77. }  
78. }  
79. /** 
80. 使用方法: 
81. QMC::input($key, $value );//写入队列 
82. $list = QMC::output($key);//读取队列 
83. */  
84. ?>  

基于PHP共享内存实现的消息队列:

1. <?php  
2. /** 
3. * 使用共享内存的PHP循环内存队列实现 
4. * 支持多进程, 支持各种数据类型的存储 
5. * 注: 完成入队或出队操作,尽快使用unset(), 以释放临界区 
6. * 
7. * @author wangbinandi@gmail.com 
8. * @created 2009-12-23 
9. */  
10. class ShmQueue  
11. {  
12. private $maxQSize = 0; // 队列最大长度  
13. private $front = 0; // 队头指针  
14. private $rear = 0;  // 队尾指针  
15. private $blockSize = 256;  // 块的大小(byte)  
16. private $memSize = 25600;  // 最大共享内存(byte)  
17. private $shmId = 0;  
18. private $filePtr = './shmq.ptr';  
19. private $semId = 0;  
20. public function __construct()  
21. {  
22. $shmkey = ftok(__FILE__, 't');  
23. $this->shmId = shmop_open($shmkey, "c", 0644, $this->memSize );  
24. $this->maxQSize = $this->memSize / $this->blockSize;  
25. // 申?一个信号量  
26. $this->semId = sem_get($shmkey, 1);  
27. sem_acquire($this->semId); // 申请进入临界区  
28. $this->init();  
29. }  
30. private function init()  
31. {  
32. if ( file_exists($this->filePtr) ){  
33. $contents = file_get_contents($this->filePtr);  
34. $data = explode( '|', $contents );  
35. if ( isset($data[0]) && isset($data[1])){  
36. $this->front = (int)$data[0];  
37. $this->rear  = (int)$data[1];  
38. }  
39. }  
40. }  
41. public function getLength()  
42. {  
43. return (($this->rear - $this->front + $this->memSize) % ($this->memSize) )/$this->blockSize;  
44. }  
45. public function enQueue( $value )  
46. {  
47. if ( $this->ptrInc($this->rear) == $this->front ){ // 队满  
48. return false;  
49. }  
50. $data = $this->encode($value);  
51. shmop_write($this->shmId, $data, $this->rear );  
52. $this->rear = $this->ptrInc($this->rear);  
53. return true;  
54. }  
55. public function deQueue()  
56. {  
57. if ( $this->front == $this->rear ){ // 队空  
58. return false;  
59. }  
60. $value = shmop_read($this->shmId, $this->front, $this->blockSize-1);  
61. $this->front = $this->ptrInc($this->front);  
62. return $this->decode($value);  
63. }  
64. private function ptrInc( $ptr )  
65. {  
66. return ($ptr + $this->blockSize) % ($this->memSize);  
67. }  
68. private function encode( $value )  
69. {  
70. $data = serialize($value) . "__eof";  
71. echo '';  
72. echo strlen($data);  
73. echo '';  
74. echo $this->blockSize -1;  
75. echo '';  
76. if ( strlen($data) > $this->blockSize -1 ){  
77. throw new Exception(strlen($data)." is overload block size!");  
78. }  
79. return $data;  
80. }  
81. private function decode( $value )  
82. {  
83. $data = explode("__eof", $value);  
84. return unserialize($data[0]);  
85. }  
86. public function __destruct()  
87. {  
88. $data = $this->front . '|' . $this->rear;  
89. file_put_contents($this->filePtr, $data);  
90. sem_release($this->semId); // 出临界区, 释放信号量  
91. }  
92. }  
93. /* 
94. // 进队操作 
95. $shmq = new ShmQueue(); 
96. $data = 'test data'; 
97. $shmq->enQueue($data); 
98. unset($shmq); 
99. // 出队操作 
100. $shmq = new ShmQueue(); 
101. $data = $shmq->deQueue(); 
102. unset($shmq); 
103. */  
104. ?> 

对于一个很大的消息队列，频繁进行进行大数据库的序列化 和 反序列化，有太耗费。下面是我用PHP 实现的一个消息队列，只需要在尾部插入一个数据，就操作尾部，不用操作整个消息队列进行读取，与操作。但是，这个消息队列不是线程安全的，我只是尽量的避免了冲突的可能性。如果消息不是非常的密集，比如几秒钟才一个，还是可以考虑这样使用的。

如果你要实现线程安全的，一个建议是通过文件进行锁定，然后进行操作。下面是代码：

1. class Memcache_Queue   
2. {   
3. private $memcache;   
4. private $name;   
5. private $prefix;   
6. function __construct($maxSize, $name, $memcache, $prefix = "__memcache_queue__")   
7. {   
8. if ($memcache == null) {   
9. throw new Exception("memcache object is null, new the object first.");   
10. }   
11. $this->memcache = $memcache;   
12. $this->name = $name;   
13. $this->prefix = $prefix;   
14. $this->maxSize = $maxSize;   
15. $this->front = 0;   
16. $this->real = 0;   
17. $this->size = 0;   
18. }   
19. function __get($name)   
20. {   
21. return $this->get($name);   
22. }   
23. function __set($name, $value)   
24. {   
25. $this->add($name, $value);   
26. return $this;   
27. }   
28. function isEmpty()   
29. {   
30. return $this->size == 0;   
31. }   
32. function isFull()   
33. {   
34. return $this->size == $this->maxSize;   
35. }   
36. function enQueue($data)   
37. {   
38. if ($this->isFull()) {   
39. throw new Exception("Queue is Full");   
40. }   
41. $this->increment("size");   
42. $this->set($this->real, $data);   
43. $this->set("real", ($this->real + 1) % $this->maxSize);   
44. return $this;   
45. }   
46. function deQueue()   
47. {   
48. if ($this->isEmpty()) {   
49. throw new Exception("Queue is Empty");   
50. }   
51. $this->decrement("size");   
52. $this->delete($this->front);   
53. $this->set("front", ($this->front + 1) % $this->maxSize);   
54. return $this;   
55. }   
56. function getTop()   
57. {   
58. return $this->get($this->front);   
59. }   
60. function getAll()   
61. {   
62. return $this->getPage();   
63. }   
64. function getPage($offset = 0, $limit = 0)   
65. {   
66. if ($this->isEmpty() || $this->size < $offset) {   
67. return null;   
68. }   
69. $keys[] = $this->getKeyByPos(($this->front + $offset) % $this->maxSize);   
70. $num = 1;   
71. for ($pos = ($this->front + $offset + 1) % $this->maxSize; $pos != $this->real; $pos = ($pos + 1) % $this->maxSize)   
72. {   
73. $keys[] = $this->getKeyByPos($pos);   
74. $num++;   
75. if ($limit > 0 && $limit == $num) {   
76. break;   
77. }   
78. }   
79. return array_values($this->memcache->get($keys));   
80. }   
81. function makeEmpty()   
82. {   
83. $keys = $this->getAllKeys();   
84. foreach ($keys as $value) {   
85. $this->delete($value);   
86. }   
87. $this->delete("real");   
88. $this->delete("front");   
89. $this->delete("size");   
90. $this->delete("maxSize");   
91. }   
92. private function getAllKeys()   
93. {   
94. if ($this->isEmpty())   
95. {   
96. return array();   
97. }   
98. $keys[] = $this->getKeyByPos($this->front);   
99. for ($pos = ($this->front + 1) % $this->maxSize; $pos != $this->real; $pos = ($pos + 1) % $this->maxSize)   
100. {   
101. $keys[] = $this->getKeyByPos($pos);   
102. }   
103. return $keys;   
104. }   
105. private function add($pos, $data)   
106. {   
107. $this->memcache->add($this->getKeyByPos($pos), $data);   
108. return $this;   
109. }   
110. private function increment($pos)   
111. {   
112. return $this->memcache->increment($this->getKeyByPos($pos));   
113. }   
114. private function decrement($pos)   
115. {   
116. $this->memcache->decrement($this->getKeyByPos($pos));   
117. }   
118. private function set($pos, $data)   
119. {   
120. $this->memcache->set($this->getKeyByPos($pos), $data);   
121. return $this;   
122. }   
123. private function get($pos)   
124. {   
125. return $this->memcache->get($this->getKeyByPos($pos));   
126. }   
127. private function delete($pos)   
128. {   
129. return $this->memcache->delete($this->getKeyByPos($pos));   
130. }   
131. private function getKeyByPos($pos)   
132. {   
133. return $this->prefix . $this->name . $pos;   
134. }   
135. }  

Tags: PHP+memcache PHP消息队列

分享到：