php结合redis实现高并发下的抢购、秒杀功能的实例

最新推荐文章于 2022-07-21 10:36:26 发布
最新推荐文章于 2022-07-21 10:36:26 发布
阅读量542 收藏 1
点赞数
分类专栏： php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37779709/article/details/79446464
版权

抢购、秒杀是如今很常见的一个应用场景，主要需要解决的问题有两个：

1 高并发对数据库产生的压力

2 竞争状态下如何解决库存的正确减少（"超卖"问题）

对于第一个问题，已经很容易想到用缓存来处理抢购，避免直接操作数据库，例如使用Redis。

重点在于第二个问题

常规写法：

查询出对应商品的库存，看是否大于0，然后执行生成订单等操作，但是在判断库存是否大于0处，如果在高并发下就会有问题，导致库存量出现负数

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<?php
$conn =mysql_connect( "localhost" , "big" , "123456" );
if (! $conn ){
     echo "connect failed" ;
     exit ;
}
mysql_select_db( "big" , $conn );
mysql_query( "set names utf8" );
 
$price =10;
$user_id =1;
$goods_id =1;
$sku_id =11;
$number =1;
 
//生成唯一订单
function build_order_no(){
   return date ( 'ymd' ). substr (implode(NULL, array_map ( 'ord' , str_split ( substr (uniqid(), 7, 13), 1))), 0, 8);
}
//记录日志
function insertLog( $event , $type =0){
     global $conn ;
     $sql ="insert into ih_log(event,type)
     values( '$event' , '$type' )";
     mysql_query( $sql , $conn );
}
 
//模拟下单操作
//库存是否大于0
$sql = "select number from ih_store where goods_id='$goods_id' and sku_id='$sku_id'" ; //解锁 此时ih_store数据中goods_id='$goods_id' and sku_id='$sku_id' 的数据被锁住(注3)，其它事务必须等待此次事务 提交后才能执行
$rs =mysql_query( $sql , $conn );
$row =mysql_fetch_assoc( $rs );
if ( $row [ 'number' ]>0){ //高并发下会导致超卖
     $order_sn =build_order_no();
     //生成订单
     $sql ="insert into ih_order(order_sn,user_id,goods_id,sku_id,price)
     values( '$order_sn' , '$user_id' , '$goods_id' , '$sku_id' , '$price' )";
     $order_rs =mysql_query( $sql , $conn );
     
     //库存减少
     $sql = "update ih_store set number=number-{$number} where sku_id='$sku_id'" ;
     $store_rs =mysql_query( $sql , $conn );
     if (mysql_affected_rows()){
         insertLog( '库存减少成功' );
     } else {
         insertLog( '库存减少失败' );
     }
} else {
     insertLog( '库存不够' );
}
?>

优化方案1：将库存字段number字段设为unsigned，当库存为0时，因为字段不能为负数，将会返回false

 

?
1
2
3
4
5
6
//库存减少
$sql = "update ih_store set number=number-{$number} where sku_id='$sku_id' and number>0" ;
$store_rs =mysql_query( $sql , $conn );
if (mysql_affected_rows()){
     insertLog( '库存减少成功' );
}

优化方案2：使用MySQL的事务，锁住操作的行

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
<?php
$conn =mysql_connect( "localhost" , "big" , "123456" );
if (! $conn ){
     echo "connect failed" ;
     exit ;
}
mysql_select_db( "big" , $conn );
mysql_query( "set names utf8" );
 
$price =10;
$user_id =1;
$goods_id =1;
$sku_id =11;
$number =1;
 
//生成唯一订单号
function build_order_no(){
   return date ( 'ymd' ). substr (implode(NULL, array_map ( 'ord' , str_split ( substr (uniqid(), 7, 13), 1))), 0, 8);
}
//记录日志
function insertLog( $event , $type =0){
     global $conn ;
     $sql ="insert into ih_log(event,type)
     values( '$event' , '$type' )";
     mysql_query( $sql , $conn );
}
 
//模拟下单操作
//库存是否大于0
mysql_query( "BEGIN" );   //开始事务
$sql = "select number from ih_store where goods_id='$goods_id' and sku_id='$sku_id' FOR UPDATE" ; //此时这条记录被锁住,其它事务必须等待此次事务提交后才能执行
$rs =mysql_query( $sql , $conn );
$row =mysql_fetch_assoc( $rs );
if ( $row [ 'number' ]>0){
     //生成订单
     $order_sn =build_order_no();
     $sql ="insert into ih_order(order_sn,user_id,goods_id,sku_id,price)
     values( '$order_sn' , '$user_id' , '$goods_id' , '$sku_id' , '$price' )";
     $order_rs =mysql_query( $sql , $conn );
     
     //库存减少
     $sql = "update ih_store set number=number-{$number} where sku_id='$sku_id'" ;
     $store_rs =mysql_query( $sql , $conn );
     if (mysql_affected_rows()){
         insertLog( '库存减少成功' );
         mysql_query( "COMMIT" ); //事务提交即解锁
     } else {
         insertLog( '库存减少失败' );
     }
} else {
     insertLog( '库存不够' );
     mysql_query( "ROLLBACK" );
}
?>

优化方案3：使用非阻塞的文件排他锁

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?php
$conn =mysql_connect( "localhost" , "root" , "123456" );
if (! $conn ){
     echo "connect failed" ;
     exit ;
}
mysql_select_db( "big-bak" , $conn );
mysql_query( "set names utf8" );
 
$price =10;
$user_id =1;
$goods_id =1;
$sku_id =11;
$number =1;
 
//生成唯一订单号
function build_order_no(){
   return date ( 'ymd' ). substr (implode(NULL, array_map ( 'ord' , str_split ( substr (uniqid(), 7, 13), 1))), 0, 8);
}
//记录日志
function insertLog( $event , $type =0){
     global $conn ;
     $sql ="insert into ih_log(event,type)
     values( '$event' , '$type' )";
     mysql_query( $sql , $conn );
}
 
$fp = fopen ( "lock.txt" , "w+" );
if (! flock ( $fp ,LOCK_EX | LOCK_NB)){
     echo "系统繁忙，请稍后再试" ;
     return ;
}
//下单
$sql = "select number from ih_store where goods_id='$goods_id' and sku_id='$sku_id'" ;
$rs =mysql_query( $sql , $conn );
$row =mysql_fetch_assoc( $rs );
if ( $row [ 'number' ]>0){ //库存是否大于0
     //模拟下单操作
     $order_sn =build_order_no();
     $sql ="insert into ih_order(order_sn,user_id,goods_id,sku_id,price)
     values( '$order_sn' , '$user_id' , '$goods_id' , '$sku_id' , '$price' )";
     $order_rs =mysql_query( $sql , $conn );
     
     //库存减少
     $sql = "update ih_store set number=number-{$number} where sku_id='$sku_id'" ;
     $store_rs =mysql_query( $sql , $conn );
     if (mysql_affected_rows()){
         insertLog( '库存减少成功' );
         flock ( $fp ,LOCK_UN); //释放锁
     } else {
         insertLog( '库存减少失败' );
     }
} else {
     insertLog( '库存不够' );
}
fclose( $fp );

优化方案4：使用redis队列，因为pop操作是原子的，即使有很多用户同时到达，也是依次执行，推荐使用（mysql事务在高并发下性能下降很厉害，文件锁的方式也是）

先将商品库存如队列

 

?
1
2
3
4
5
6
7
8
9
10
11
12
<?php
$store =1000;
$redis = new Redis();
$result = $redis ->connect( '127.0.0.1' ,6379);
$res = $redis ->llen( 'goods_store' );
echo $res ;
$count = $store - $res ;
for ( $i =0; $i < $count ; $i ++){
     $redis ->lpush( 'goods_store' ,1);
}
echo $redis ->llen( 'goods_store' );
?>

抢购、描述逻辑

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<?php
$conn =mysql_connect( "localhost" , "big" , "123456" );
if (! $conn ){
     echo "connect failed" ;
     exit ;
}
mysql_select_db( "big" , $conn );
mysql_query( "set names utf8" );
 
$price =10;
$user_id =1;
$goods_id =1;
$sku_id =11;
$number =1;
 
//生成唯一订单号
function build_order_no(){
   return date ( 'ymd' ). substr (implode(NULL, array_map ( 'ord' , str_split ( substr (uniqid(), 7, 13), 1))), 0, 8);
}
//记录日志
function insertLog( $event , $type =0){
     global $conn ;
     $sql ="insert into ih_log(event,type)
     values( '$event' , '$type' )";
     mysql_query( $sql , $conn );
}
 
//模拟下单操作
//下单前判断redis队列库存量
$redis = new Redis();
$result = $redis ->connect( '127.0.0.1' ,6379);
$count = $redis ->lpop( 'goods_store' );
if (! $count ){
     insertLog( 'error:no store redis' );
     return ;
}
 
//生成订单
$order_sn =build_order_no();
$sql ="insert into ih_order(order_sn,user_id,goods_id,sku_id,price)
values( '$order_sn' , '$user_id' , '$goods_id' , '$sku_id' , '$price' )";
$order_rs =mysql_query( $sql , $conn );
 
//库存减少
$sql = "update ih_store set number=number-{$number} where sku_id='$sku_id'" ;
$store_rs =mysql_query( $sql , $conn );
if (mysql_affected_rows()){
     insertLog( '库存减少成功' );
} else {
     insertLog( '库存减少失败' );
}

模拟5000高并发测试

webbench -c 5000 -t 60 http://192.168.1.198/big/index.php
ab -r -n 6000 -c 5000  http://192.168.1.198/big/index.php

上述只是简单模拟高并发下的抢购，真实场景要比这复杂很多，很多注意的地方

如抢购页面做成静态的，通过ajax调用接口

再如上面的会导致一个用户抢多个，思路：

需要一个排队队列和抢购结果队列及库存队列。高并发情况，先将用户进入排队队列，用一个线程循环处理从排队队列取出一个用户，判断用户是否已在抢购结果队列，如果在，则已抢购，否则未抢购，库存减1，写数据库，将用户入结果队列。

测试数据表

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
--
-- 数据库: `big`
--
 
-- --------------------------------------------------------
 
--
-- 表的结构 `ih_goods`
--
 
 
CREATE TABLE IF NOT EXISTS `ih_goods` (
   `goods_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
   `cat_id` int(11) NOT NULL,
   `goods_name` varchar(255) NOT NULL,
   PRIMARY KEY (`goods_id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=2 ;
 
 
--
-- 转存表中的数据 `ih_goods`
--
 
 
INSERT INTO `ih_goods` (`goods_id`, `cat_id`, `goods_name`) VALUES
(1, 0, '小米手机' );
 
-- --------------------------------------------------------
 
--
-- 表的结构 `ih_log`
--
 
CREATE TABLE IF NOT EXISTS `ih_log` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `event` varchar(255) NOT NULL,
  `type` tinyint(4) NOT NULL DEFAULT '0' ,
  `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
 
--
-- 转存表中的数据 `ih_log`
--
 
 
-- --------------------------------------------------------
 
--
-- 表的结构 `ih_order`
--
 
CREATE TABLE IF NOT EXISTS `ih_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `order_sn` char(32) NOT NULL,
  `user_id` int(11) NOT NULL,
  `status` int(11) NOT NULL DEFAULT '0' ,
  `goods_id` int(11) NOT NULL DEFAULT '0' ,
  `sku_id` int(11) NOT NULL DEFAULT '0' ,
  `price` float NOT NULL,
  `addtime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT= '订单表' AUTO_INCREMENT=1 ;
 
--
-- 转存表中的数据 `ih_order`
--
 
 
-- --------------------------------------------------------
 
--
-- 表的结构 `ih_store`
--
 
CREATE TABLE IF NOT EXISTS `ih_store` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `goods_id` int(11) NOT NULL,
  `sku_id` int(10) unsigned NOT NULL DEFAULT '0' ,
  `number` int(10) NOT NULL DEFAULT '0' ,
  `freez` int(11) NOT NULL DEFAULT '0' COMMENT '虚拟库存' ,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT= '库存' AUTO_INCREMENT=2 ;
 
--
-- 转存表中的数据 `ih_store`
--
 
INSERT INTO `ih_store` (`id`, `goods_id`, `sku_id`, `number`, `freez`) VALUES
(1, 1, 11, 500, 0);

以上就是小编为大家带来的php结合redis实现高并发下的抢购、秒杀功能的实例全部内容了，希望大家多多支持脚本之家~

社会刘
关注
专栏目录
php redis 队列抢红包_php结合redis实现高并发下的抢购、秒杀功能的实例
weixin_39927408的博客
12-22 454
抢购、秒杀是如今很常见的一个应用场景，主要需要解决的问题有两个：1 高并发对数据库产生的压力2 竞争状态下如何解决库存的正确减少("超卖"问题)对于第一个问题，已经很容易想到用缓存来处理抢购，避免直接操作数据库，例如使用Redis。重点在于第二个问题常规写法：查询出对应商品的库存，看是否大于0，然后执行生成订单等操作，但是在判断库存是否大于0处，如果在高并发下就会有问题，导致库存量出现负数$con...
用redis实现悲观锁（后端语言以php为例）
grey256的博客
03-16 8358
锁机制通常使用的锁分为乐观锁，悲观锁这两种，简单介绍下这两种锁，作为本文的背景知识，对这类知识已经有足够了解的同学可以跳过这部分。乐观锁先来看下百度百科上的解释：[大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此
PHP和Redis实现在高并发下的抢购及秒杀功能示例详解
m0_37477061的博客
06-18 224
http://www.thinkphp.cn/topic/50641.html
redis+php+mysql处理高并发实例
weixin_34261739的博客
08-05 165
一、实验环境ubuntu、php、apache或nginx、mysql二、需求现在有一个接口可能会出现并发量比较大的情况，这个接口使用php写的，做的功能是接收 用户的GET请求中的name字段，然后将这个字段存到mysql中，现在先将数据放到redis的队列中，然后让redis定时将这些数据转移到mysql中。二、实现步骤1.新建数据库...
php mysql redis实战_redis+php+mysql处理高并发实例
weixin_42323034的博客
01-18 267
一、实验环境ubuntu、php、apache或nginx、mysql二、实现步骤1.新建数据库test及 数据表test，建表语句如下CREATE TABLE `test` (`name` varchar(255) DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf-81.在/var/www/test中新建index.php,内容如下，并配置虚拟主机使...
php-redis解决高并发案例
zhazhaji的博客
12-13 615
<?php //本脚本依赖 php-redis扩展，请自行安装 //商品 class Good { //名字 protected $name; //商品id protected $id; //库存 protected $stock; public function __construct(string $name, int $id, ...
PHP+Redis事务解决高并发下商品超卖问题(推荐)
10-15
在电商系统中，高并发场景下的商品超卖问题是一个常见的挑战。传统的解决方案通常是依赖于数据库的事务机制，但在用户量较大且流量集中的情况下，仅仅依靠关系型数据库（如MySQL、Oracle）可能会导致数据库压力过大...
PHP利用Redis 事务实现商品秒杀
u014225032的博客
07-21 2599
PHP实现秒杀
基于PHP+redis的秒杀系统
04-16
基于PHP+redis的秒杀系统
php结合redis实现高并发下的抢购、秒杀功能
weixin_33748818的博客
10-18 419
抢购、秒杀是如今很常见的一个应用场景，主要需要解决的问题有两个：1 高并发对数据库产生的压力2 竞争状态下如何解决库存的正确减少（"超卖"问题）对于第一个问题，已经很容易想到用缓存来处理抢购，避免直接操作数据库，例如使用Redis。重点在于第二个问题 常规写法： 查询出对应商品的库存，看是否大于0，然后执行生成订单等操作，但是在判断库存是否大于0处，如果在高并发下就会有问题，导致库存量出现负数  ...
PHP中利用redis实现消息队列处理高并发请求--简洁代码实现效果
一亩地的专栏
10-11 5850
将请求存入redis 为了模拟多个用户的请求,使用一个for循环替代 //redis数据入队操作 $redis = new Redis(); $redis->connect('127.0.0.1',6379); for($i=0;$i$i++){ try{ $redis->LPUSH('click',rand(1000,5000)); }catch(Except
【高并发简单解决方案】redis队列缓存 + mysql 批量入库 + php离线整合
weixin_34310127的博客
12-12 281
需求背景：有个调用统计日志存储和统计需求，要求存储到mysql中；存储数据高峰能达到日均千万，瓶颈在于直接入库并发太高，可能会把mysql干垮。 问题分析 思考：应用网站架构的衍化过程中，应用最新的框架和工具技术固然是最优选择；但是，如果能在现有的框架的基础上提出简单可依赖的解决方案，未尝不是一种提升自我的尝试。 解决： 问题一：要求日...
php结合redis高并发下发帖、发微博
topofgods的博客
06-05 455
转自 http://blog.csdn.net/nuli888/article/details/52443310 发帖、发微博、点赞、评论等这些操作很频繁的动作如果并发量小，直接入库是最简单的 但是并发量一大，数据库肯定扛不住，这时可采取延迟发布：先将发布动作保存在队列里，后台进程循环获取再入库 模拟发布微博先进入Redis队列 weibo_redis.PHP  
php redis分布式锁和任务队列代码实例详解
zeicool的专栏
03-19 2756
1.Redis实现分布式锁思路　　思路很简单，主要用到的redis函数是setnx()，这个应该是实现分布式锁最主要的函数。首先是将某一任务标识名（这里用Lock:order作为标识名的例子）作为键存到redis里，并为其设个过期时间，如果是还有Lock:order请求过来，先是通过setnx()看看是否能将Lock:order插入到redis里，可以的话就返回true，不可以就返回false。当...
关于php高并发解决的一点思路
weixin_30861797的博客
05-08 263
涉及抢购、秒杀、抽奖、抢票等活动时，为了避免超卖，那么库存数量是有限的，但是如果同时下单人数超过了库存数量，就会导致商品超卖问题。那么我们怎么来解决这个问题呢，我的思路如下(伪代码)： sql1:查询商品库存 if(库存数量 > 0) { //生成订单... sql2:同时库存-1 } 当没有并发时，上面的流程看起来是再正常不过了，假设同时两个人下单，而...
高并发秒杀系统总结
weixin_34198762的博客
09-18 746
大家也许开发过高并发的系统或者秒杀程序，但肯定都有接触过，像电商平台的秒杀、抢购等活动，还有12306春运抢票。 活动周期短，瞬间流量大(高并发)，技术在这种情况下，会发生和要做的事。 第一：高并发 技术要做的事，一方面优化程序，让程序性能最优，单次请求时间能从50ms优化到25ms，那就可以在一秒钟内成功响应翻倍的请求了。 另一方面就是增加服务器，用更大的集群来处理用户请求，设计好一个可...
redis抽奖并发_redis实现高并发下的抢购/秒杀功能
最新发布
05-12
Redis可以通过使用事务或Lua脚本来实现高并发下的抢购/秒杀功能。 1. 使用事务：抢购/秒杀的过程可以看做是一个先检查库存是否充足，再扣减库存的过程。使用Redis的事务可以保证这个过程是原子性的，即要么全部成功...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值