并发下常见的加锁及锁的PHP具体实现

并发下常见的加锁及锁的PHP具体实现

在最近的项目中有这样的场景
1.生成文件的时候,由于多用户都有权限进行生成,防止并发下,导致生成的结果出现错误,需要对生成的过程进行加锁,只容许一个用户在一个时间内进行操作,这个时候就需要用到锁了,将这个操作过程锁起来.
2.在用了cache的时候,cache失效可能导致瞬间的多数并发请求穿透到数据库此时也可以得需要用锁在同一并发的过程中将这个操作锁定.
针对以上的2种情况,现在的解决方法是对处理过程进行锁机制,通过PHP实现如下
用到了Eaccelerator的内存锁 和 文件锁,原理如下
判断系统中是否安了EAccelerator 如果有则使用内存锁,如果不存在,则进行文件锁
根据带入的key的不同可以实现多个锁直接的并行处理,类似Innodb的行级锁
使用如下:
$lock = new CacheLock('key_name');
$lock->lock();
//logic here
$lock->unlock();
//使用过程中需要注意下文件锁所在路径需要有写权限.
具体类如下:

[php] view plain copy print?

1. <?php  

2. /** 

3.  * CacheLock 进程锁,主要用来进行cache失效时的单进程cache获取，防止过多的SQL请求穿透到数据库 

4.  * 用于解决PHP在并发时候的锁控制,通过文件/eaccelerator进行进程间锁定 

5.  * 如果没有使用eaccelerator则进行进行文件锁处理，会做对应目录下产生对应粒度的锁 

6.  * 使用了eaccelerator则在内存中处理，性能相对较高 

7.  * 不同的锁之间并行执行，类似mysql innodb的行级锁 

8.  * 本类在sunli的phplock的基础上做了少许修改  http://code.google.com/p/phplock  

9.  * @author yangxinqi 

10.  * 

11.  */  

12. class CacheLock  

13. {  

14.     //文件锁存放路径  

15.     private $path = null;  

16.     //文件句柄  

17.     private $fp = null;  

18.     //锁粒度,设置越大粒度越小  

19.     private $hashNum = 100;  

20.     //cache key   

21.     private $name;  

22.     //是否存在eaccelerator标志  

23.     private  $eAccelerator = false;  

24.       

25.     /** 

26.      * 构造函数 

27.      * 传入锁的存放路径，及cache key的名称，这样可以进行并发 

28.      * @param string $path 锁的存放目录，以"/"结尾 

29.      * @param string $name cache key 

30.      */  

31.     public function __construct($name,$path='lock/')  

32.     {  

33.         //判断是否存在eAccelerator,这里启用了eAccelerator之后可以进行内存锁提高效率  

34.         $this->eAccelerator = function_exists("eaccelerator_lock");  

35.         if(!$this->eAccelerator)  

36.         {  

37.             $this->path = $path.($this->_mycrc32($name) % $this->hashNum).'.txt';  

38.         }  

39.         $this->name = $name;  

40.     }  

41.       

42.     /** 

43.      * crc32 

44.      * crc32封装 

45.      * @param int $string 

46.      * @return int 

47.      */  

48.     private function _mycrc32($string)  

49.     {  

50.         $crc = abs (crc32($string));  

51.         if ($crc & 0x80000000) {  

52.             $crc ^= 0xffffffff;  

53.             $crc += 1;  

54.         }  

55.         return $crc;  

56.     }  

57.     /** 

58.      * 加锁 

59.      * Enter description here ... 

60.      */  

61.     public function lock()  

62.     {  

63.         //如果无法开启ea内存锁，则开启文件锁  

64.         if(!$this->eAccelerator)  

65.         {  

66.             //配置目录权限可写  

67.             $this->fp = fopen($this->path, 'w+');  

68.             if($this->fp === false)  

69.             {  

70.                 return false;  

71.             }  

72.             return flock($this->fp, LOCK_EX);  

73.         }else{  

74.             return eaccelerator_lock($this->name);  

75.         }  

76.     }  

77.       

78.     /** 

79.      * 解锁 

80.      * Enter description here ... 

81.      */  

82.     public function unlock()  

83.     {  

84.         if(!$this->eAccelerator)  

85.         {  

86.             if($this->fp !== false)  

87.             {  

88.                 flock($this->fp, LOCK_UN);  

89.                 clearstatcache();  

90.             }  

91.             //进行关闭  

92.             fclose($this->fp);  

93.         }else{  

94.             return eaccelerator_unlock($this->name);  

95.         }  

96.     }  

97. }  

98. $lock = new CacheLock('key_name');  

99.   

100. $lock->lock();  

101. //logic here  

102.   

103. echo "111.<br />";  

104. sleep(1);  

105.   

106. $lock->unlock();  

107. //使用过程中需要注意下文件锁所在路径需要有写权限.  

108.   

109.   

110. ?>  

php解决抢购秒杀抽奖等大流量并发入库导致的库存负数的问题

最近在做一个团购项目，遇到个问题，就是在抢购、秒杀、抽奖等活动时，库存数量有限，但是同时下单人数超过了库存数量，就会导致商品超售问题。那么我们怎么来解决这个问题呢，我的思路如下：

我们知道数据库处理sql是一条条处理的，假设购买商品的流程是这样的：

sql1:查询商品库存

[sql] view plain copy print?

1. if(库存数量 > 0)  

2. {  

3.   //生成订单...  

4.   sql2:库存-1  

5. }  

当没有并发时，上面的流程看起来是如此完美，假设同时两个人下单，而库存只有1个了，在sql1阶段两个人查询到的库存都是>0的，于是最终都执行了sql2，库存最后变为-1，超售了，要么补库存，要么等用户投诉吧。

解决这个问题比较流行的思路：

1.用额外的单进程处理一个队列，下单请求放到队列里，一个个处理，就不会有并发的问题了，但是要额外的后台进程以及延迟问题，不予考虑。

2.数据库乐观锁，大致的意思是先查询库存，然后立马将库存+1，然后订单生成后，在更新库存前再查询一次库存，看看跟预期的库存数量是否保持一致，不一致就回滚，提示用户库存不足。

3.根据update结果来判断，我们可以在sql2的时候加一个判断条件update ... where 库存>0，如果返回false，则说明库存不足，并回滚事务。

4.借助文件排他锁，在处理下单请求的时候，用flock锁定一个文件，如果锁定失败说明有其他订单正在处理，此时要么等待要么直接提示用户"服务器繁忙"

本文要说的是第4种方案，大致代码如下：

阻塞(等待)模式

[php] view plain copy print?

1. <?php  

2. $fp = fopen("lock.txt", "w+");  

3. if(flock($fp,LOCK_EX))  

4. {  

5.   //..处理订单  

6.   flock($fp,LOCK_UN);  

7. }  

8. fclose($fp);  

9. ?>  

非阻塞模式

[php] view plain copy print?

1. <?php  

2. $fp = fopen("lock.txt", "w+");  

3. if(flock($fp,LOCK_EX | LOCK_NB))  

4. {  

5.   //..处理订单  

6.   flock($fp,LOCK_UN);  

7. }  

8. else  

9. {  

10.   echo "系统繁忙，请稍后再试";  

11. }  

12.    

13. fclose($fp);  

14. ?>  

15. 
    

转载于:https://blog.51cto.com/8560232/1882299