php 高并发防止超卖

PHP高并发情况下防止商品库存超卖 | PHP 技术论坛
https://learnku.com/articles/66811

php 防止库存超卖之并发测试 | PHP 技术论坛
https://learnku.com/articles/66812

商城系统中，抢购和秒杀是很常见的营销场景，在一定时间内有大量的用户访问商场下单，主要需要解决的问题有两个：

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

2. 竞争状态下如何解决商品库存超卖；

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

对于第一个问题，使用缓存来处理，避免直接操作数据库，例如使用 Redis。

竞争状态下如何解决商品库存超卖

对于第二个问题，需要重点说明。

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

测试表 sql
把如下表数据导入到数据库中

  1. /*
  2. Navicat MySQL Data Transfer
  4. Source Server         : 01 本地localhost
  5. Source Server Version : 50553
  6. Source Host           : localhost:3306
  7. Source Database       : test
  9. Target Server Type    : MYSQL
  10. Target Server Version : 50553
  11. File Encoding         : 65001
  13. Date: 2020-11-06 14:31:35
  14. */
  15.  
  16. SET FOREIGN_KEY_CHECKS=0;
  17.  
  18. -- ----------------------------
  19. -- Table structure for products
  20. -- ----------------------------
  21. DROP TABLE IF EXISTS `products`;
  22. CREATE TABLE `products` (
  23.   `id` int(10) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  24.   `title` varchar(50) DEFAULT NULL COMMENT '货品名称',
  25.   `store` int(11) DEFAULT '0' COMMENT '货品库存',
  26.   PRIMARY KEY (`id`)
  27. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='货品表';
  28.  
  29. -- ----------------------------
  30. -- Records of products
  31. -- ----------------------------
  32. INSERT INTO `products` VALUES ('1', '稻花香大米', '20');
  33.  
  34. -- ----------------------------
  35. -- Table structure for order_log
  36. -- ----------------------------
  37. DROP TABLE IF EXISTS `order_log`;
  38. CREATE TABLE `order_log` (
  39.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  40.   `content` varchar(255) CHARACTER SET utf8mb4 DEFAULT NULL COMMENT '日志内容',
  41.   `c_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  42.   PRIMARY KEY (`id`)
  43. ) ENGINE=MyISAM DEFAULT CHARSET=latin1;
  44.  
  45. -- ----------------------------
  46. -- Table structure for order
  47. -- ----------------------------
  48. DROP TABLE IF EXISTS `order`;
  49. CREATE TABLE `order` (
  50.   `oid` bigint(20) unsigned NOT NULL DEFAULT '0' COMMENT '订单号',
  51.   `product_id` int(11) DEFAULT '0' COMMENT '商品ID',
  52.   `number` int(11) DEFAULT '0' COMMENT '购买数量',
  53.   `c_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  54.   PRIMARY KEY (`oid`)
  55. ) ENGINE=MyISAM DEFAULT CHARSET=latin1 COMMENT='订单表';

下单处理代码

  1. <?php
  2.  
  3. db();
  4. global $con;
  5.  
  6. //step1 接收下单参数
  7. $product_id = 1;// 商品ID
  8. $buy_num = 1;// 购买数量
  9.  
  10. //step2 查询商品信息
  11. $sql = "select * from products where id={$product_id}";
  12. $result = mysqli_query($con, $sql);
  13. $row = mysqli_fetch_assoc($result);
  14.  
  15. //step3 判断商品下单数量是否大于商品库存数量
  16. //此处在高并发下，可能出现上一个下单后还没来得及更新库存，下一个下单判断库存数不是最新的库存
  17. if ($row['store'] > 0) {
  18.  
  19.     sleep(1);
  20.     //step4 更新商品库存数量（减去下单数量）
  21.     $sql = "update products set store=store-{$buy_num} where id={$product_id}";
  22.     if (mysqli_query($con, $sql)) {
  23.         echo "更新成功";
  24.         //step5 生成订单号创建订单
  25.         $oid = build_order_no();
  26.         create_order($oid, $product_id, $buy_num);
  27.         insertLog('库存减少成功，下单成功');
  28.     } else {
  29.         echo "更新失败";
  30.         insertLog('库存减少失败');
  31.     }
  32.  
  33. } else {
  34.     echo "没有库存";
  35.     insertLog('库存不够');
  36. }
  37.  
  38. function db()
  39. {
  40.     global $con;
  41.     $con = new mysqli('localhost','root','root','test');
  42.     if (!$con) {
  43.         echo "数据库连接失败";
  44.     }
  45. }
  46.  
  47. /**
  48.  * 生成唯一订单号
  49.  */
  50. function build_order_no()
  51. {
  52.     return date('Ymd') . str_pad(mt_rand(1, 99999), 5, '0', STR_PAD_LEFT);
  53. }
  54.  
  55. function create_order($oid, $product_id, $number)
  56. {
  57.     global $con;
  58.     $sql = "INSERT INTO `order` (oid, product_id, number) values('$oid', '$product_id', '$number')";
  59.     mysqli_query($con, $sql);
  60. }
  61.  
  62. /**
  63.  * 记录日志
  64.  */
  65. function insertLog($content)
  66. {
  67.     global $con;
  68.     $sql = "INSERT INTO `order_log` (content) values('$content')";
  69.     mysqli_query($con, $sql);
  70. }

 将库存字段字段设为 unsigned

因为库存字段不能为负数，在下单后更新商品库存时，如果出现负数将返回 false

  1. <?php
  2. db();
  3. global $con;
  4.  
  5. //step1 接收下单参数
  6. $product_id = 1;// 商品ID
  7. $buy_num = 1;// 购买数量
  8.  
  9. //step2 查询商品信息
  10. $sql = "select * from products where id={$product_id} for UPDATE";//利用for update 开启行锁
  11. $result = mysqli_query($con, $sql);
  12. $row = mysqli_fetch_assoc($result);
  13.  
  14. //step3 判断商品下单数量是否大于商品库存数量
  15. if ($row['store'] > 0) {
  16.  
  17.     sleep(1);
  18.     //step4 更新商品库存数量（减去下单数量）
  19.     $sql = "update products set store=store-{$buy_num} where id={$product_id}";
  20.     if (mysqli_query($con, $sql)) {
  21.         echo "更新成功";
  22.         //step5 生成订单号创建订单
  23.         $oid = build_order_no();
  24.         create_order($oid, $product_id, $buy_num);
  25.         insertLog('库存减少成功，下单成功');
  26.     } else {
  27.         // 如果出现负数将返回false
  28.         echo "更新失败";
  29.         insertLog('库存减少失败');
  30.     }
  31. } else {
  32.     //商品已经抢购完
  33.     echo "没有库存";
  34.     insertLog('库存不够');
  35. }
  36.  
  37. function db()
  38. {
  39.     global $con;
  40.     $con = new mysqli('localhost','root','root','test');
  41.     if (!$con) {
  42.         echo "数据库连接失败";
  43.     }
  44. }
  45.  
  46. /**
  47.  * 生成唯一订单号
  48.  */
  49. function build_order_no()
  50. {
  51.     return date('Ymd') . str_pad(mt_rand(1, 99999), 5, '0', STR_PAD_LEFT);
  52. }
  53.  
  54. function create_order($oid, $product_id, $number)
  55. {
  56.     global $con;
  57.     $sql = "INSERT INTO `order` (oid, product_id, number) values('$oid', '$product_id', '$number')";
  58.     mysqli_query($con, $sql);
  59. }
  60.  
  61. /**
  62.  * 记录日志
  63.  */
  64. function insertLog($content)
  65. {
  66.     global $con;
  67.     $sql = "INSERT INTO `order_log` (content) values('$content')";
  68.     mysqli_query($con, $sql);
  69. }

使用 mysql 的事务，锁住操作的行

在下单处理过程中，使用 mysql 的事务将正在下单商品行数据锁定

  1. <?php
  2. db();
  3. global $con;
  4.  
  5. //step1 接收下单参数
  6. $product_id = 1;// 商品ID
  7. $buy_num = 1;// 购买数量
  8.  
  9. mysqli_query($con, "BEGIN"); //开始事务
  10.  
  11. //step2 查询商品信息
  12. $sql = "select * from products where id={$product_id} for UPDATE";//利用for update 开启行锁
  13. $result = mysqli_query($con, $sql);
  14. $row = mysqli_fetch_assoc($result);
  15.  
  16. //step3 判断商品下单数量是否大于商品库存数量
  17. if ($row['store'] > 0) {
  18.  
  19.     sleep(1);
  20.     //step4 更新商品库存数量（减去下单数量）
  21.     $sql = "update products set store=store-{$buy_num} where id={$product_id}";
  22.     if (mysqli_query($con, $sql)) {
  23.         echo "更新成功";
  24.         //step5 生成订单号创建订单
  25.         $oid = build_order_no();
  26.         create_order($oid, $product_id, $buy_num);
  27.         insertLog('库存减少成功，下单成功');
  28.         mysqli_query($con, "COMMIT");//事务提交即解锁
  29.     } else {
  30.         echo "更新失败";
  31.         insertLog('库存减少失败');
  32.         mysqli_query($con, "ROLLBACK");//事务回滚即解锁
  33.     }
  34. } else {
  35.     //商品已经抢购完
  36.     echo "没有库存";
  37.     insertLog('库存不够');
  38.     mysqli_query($con, "ROLLBACK");//事务回滚即解锁
  39. }
  40.  
  41. function db()
  42. {
  43.     global $con;
  44.     $con = new mysqli('localhost','root','root','test');
  45.     if (!$con) {
  46.         echo "数据库连接失败";
  47.     }
  48. }
  49.  
  50. /**
  51.  * 生成唯一订单号
  52.  */
  53. function build_order_no()
  54. {
  55.     return date('Ymd') . str_pad(mt_rand(1, 99999), 5, '0', STR_PAD_LEFT);
  56. }
  57.  
  58. function create_order($oid, $product_id, $number)
  59. {
  60.     global $con;
  61.     $sql = "INSERT INTO `order` (oid, product_id, number) values('$oid', '$product_id', '$number')";
  62.     mysqli_query($con, $sql);
  63. }
  64.  
  65. /**
  66.  * 记录日志
  67.  */
  68. function insertLog($content)
  69. {
  70.     global $con;
  71.     $sql = "INSERT INTO `order_log` (content) values('$content')";
  72.     mysqli_query($con, $sql);
  73. }

使用非阻塞的文件排他锁
在处理下单请求的时候，用 flock 锁定一个文件，如果锁定失败说明有其他订单正在处理，此时要么等待要么直接提示用户” 服务器繁忙”，计数器存储抢购的商品数量，避免查询数据库。

阻塞 (等待) 模式：并发时，当有第二个用户请求时，会等待第一个用户请求完成、释放锁，获得文件锁之后，程序才会继续运行下去。

  1. <?php
  2. db();
  3. global $con;
  4.  
  5. //step1 接收下单参数
  6. $product_id = 1;// 商品ID
  7. $buy_num = 1;// 购买数量
  8.  
  9. $fp = fopen('lock.txt', 'w');
  10. if (flock($fp, LOCK_EX)) {   //文件独占锁,阻塞
  11.     //step2 查询商品信息
  12.     $sql = "select * from products where id={$product_id}";
  13.     $result = mysqli_query($con, $sql);
  14.     $row = mysqli_fetch_assoc($result);
  15.  
  16.     //step3 判断商品下单数量是否大于商品库存数量
  17.     if ($row['store'] > 0) {
  18.         //处理订单
  19.         sleep(1);
  20.         //step4 更新商品库存数量（减去下单数量）
  21.         $sql = "update products set store=store-{$buy_num} where id={$product_id}";
  22.         if (mysqli_query($con, $sql)) {
  23.             echo "更新成功";
  24.             //step5 生成订单号创建订单
  25.             $oid = build_order_no();
  26.             create_order($oid, $product_id, $buy_num);
  27.             insertLog('库存减少成功，下单成功');
  28.         } else {
  29.             echo "更新失败";
  30.             insertLog('库存减少失败');
  31.         }
  32.     } else {
  33.         //商品已经抢购完
  34.         echo "没有库存";
  35.         insertLog('库存不够');
  36.     }
  37.     flock($fp, LOCK_UN); //释放锁
  38.  
  39. }
  40. fclose($fp);
  41.  
  42. function db()
  43. {
  44.     global $con;
  45.     $con = new mysqli('localhost','root','root','test');
  46.     if (!$con) {
  47.         echo "数据库连接失败";
  48.     }
  49. }
  50.  
  51. /**
  52.  * 生成唯一订单号
  53.  */
  54. function build_order_no()
  55. {
  56.     return date('Ymd') . str_pad(mt_rand(1, 99999), 5, '0', STR_PAD_LEFT);
  57. }
  58.  
  59. function create_order($oid, $product_id, $number)
  60. {
  61.     global $con;
  62.     $sql = "INSERT INTO `order` (oid, product_id, number) values('$oid', '$product_id', '$number')";
  63.     mysqli_query($con, $sql);
  64. }
  65.  
  66. /**
  67.  * 记录日志
  68.  */
  69. function insertLog($content)
  70. {
  71.     global $con;
  72.     $sql = "INSERT INTO `order_log` (content) values('$content')";
  73.     mysqli_query($con, $sql);
  74. }

 非阻塞模式：并发时，第一个用户请求，拿得文件锁之后。后面请求的用户直接返回系统繁忙，请稍后再试

  1. <?php
  2. db();
  3. global $con;
  4.  
  5. //step1 接收下单参数
  6. $product_id = 1;// 商品ID
  7. $buy_num = 1;// 购买数量
  8.  
  9. $fp = fopen('lock.txt', 'w');
  10. if (flock($fp, LOCK_EX|LOCK_NB)) {   //文件独占锁,非阻塞
  11.     //step2 查询商品信息
  12.     $sql = "select * from products where id={$product_id}";
  13.     $result = mysqli_query($con, $sql);
  14.     $row = mysqli_fetch_assoc($result);
  15.  
  16.     //step3 判断商品下单数量是否大于商品库存数量
  17.     if ($row['store'] > 0) {
  18.         //处理订单
  19.         sleep(1);
  20.         //step4 更新商品库存数量（减去下单数量）
  21.         $sql = "update products set store=store-{$buy_num} where id={$product_id}";
  22.         if (mysqli_query($con, $sql)) {
  23.             echo "更新成功";
  24.             //step5 生成订单号创建订单
  25.             $oid = build_order_no();
  26.             create_order($oid, $product_id, $buy_num);
  27.             insertLog('库存减少成功，下单成功');
  28.         } else {
  29.             echo "更新失败";
  30.             insertLog('库存减少失败');
  31.         }
  32.     } else {
  33.         //商品已经抢购完
  34.         echo "没有库存";
  35.         insertLog('库存不够');
  36.     }
  37.     flock($fp, LOCK_UN); //释放锁
  38.  
  39. } else {
  40.     //系统繁忙，请稍后再试
  41.     echo "系统繁忙，请稍后再试";
  42.     insertLog('系统繁忙，请稍后再试');
  43. }
  44. fclose($fp);
  45.  
  46. function db()
  47. {
  48.     global $con;
  49.     $con = new mysqli('localhost','root','root','test');
  50.     if (!$con) {
  51.         echo "数据库连接失败";
  52.     }
  53. }
  54.  
  55. /**
  56.  * 生成唯一订单号
  57.  */
  58. function build_order_no()
  59. {
  60.     return date('Ymd') . str_pad(mt_rand(1, 99999), 5, '0', STR_PAD_LEFT);
  61. }
  62.  
  63. function create_order($oid, $product_id, $number)
  64. {
  65.     global $con;
  66.     $sql = "INSERT INTO `order` (oid, product_id, number) values('$oid', '$product_id', '$number')";
  67.     mysqli_query($con, $sql);
  68. }
  69.  
  70. /**
  71.  * 记录日志
  72.  */
  73. function insertLog($content)
  74. {
  75.     global $con;
  76.     $sql = "INSERT INTO `order_log` (content) values('$content')";
  77.     mysqli_query($con, $sql);
  78. }

使用 redis 队列

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

  1. 先将商品库存到 redis 队列

  1. <?php
  2.  
  3. db();
  4. global $con;
  5.  
  6. // 查询商品信息
  7. $product_id = 1;
  8. $sql = "select * from products where id={$product_id}";
  9. $result = mysqli_query($con, $sql);
  10. $row = mysqli_fetch_assoc($result);
  11. $store = $row['store'];
  12.  
  13. // 获取商品在redis缓存的库存
  14. $redis = new Redis();
  15. $result = $redis->connect('127.0.0.1', 6379);
  16. $key = 'goods_store_' . $product_id;
  17. $res = $redis->llen($key);
  18. $count = $store - $res;
  19.  
  20. for ($i=0; $i<$count; $i++) {
  21.     $redis->lpush($key, 1);
  22. }
  23. echo $redis->llen($key);
  24.  
  25. function db()
  26. {
  27.     global $con;
  28.     $con = new mysqli('localhost','root','root','test');
  29.     if (!$con) {
  30.         echo "数据库连接失败";
  31.     }
  32. }

2. 抢购、秒杀逻辑

  1. <?php
  2.  
  3. db();
  4. global $con;
  5.  
  6. //step1 接收下单参数
  7. $product_id = 1;// 商品ID
  8. $buy_num = 1;// 购买数量
  9.  
  10. //step2 下单前判断redis队列库存量
  11. $redis = new Redis();
  12. $result = $redis->connect('127.0.0.1',6379);
  13. $count = $redis->lpop('goods_store_' . $product_id);
  14. if (!$count) {
  15.     insertLog('error:no store redis');
  16.     return '秒杀结束，没有商品库存了';
  17. }
  18.  
  19. sleep(1);
  20. //step3 更新商品库存数量（减去下单数量）
  21. $sql = "update products set store=store-{$buy_num} where id={$product_id}";
  22. if (mysqli_query($con, $sql)) {
  23.     echo "更新成功";
  24.     //step4 生成订单号创建订单
  25.     $oid = build_order_no();
  26.     create_order($oid, $product_id, $buy_num);
  27.     insertLog('库存减少成功，下单成功');
  28. } else {
  29.     echo "更新失败";
  30.     insertLog('库存减少失败');
  31. }
  32.  
  33. function db()
  34. {
  35.     global $con;
  36.     $con = new mysqli('localhost','root','root','test');
  37.     if (!$con) {
  38.         echo "数据库连接失败";
  39.     }
  40. }
  41.  
  42. /**
  43.  * 生成唯一订单号
  44.  */
  45. function build_order_no()
  46. {
  47.     return date('Ymd') . str_pad(mt_rand(1, 99999), 5, '0', STR_PAD_LEFT);
  48. }
  49.  
  50. function create_order($oid, $product_id, $number)
  51. {
  52.     global $con;
  53.     $sql = "INSERT INTO `order` (oid, product_id, number) values('$oid', '$product_id', '$number')";
  54.     mysqli_query($con, $sql);
  55. }
  56.  
  57. /**
  58.  * 记录日志
  59.  */
  60. function insertLog($content)
  61. {
  62.     global $con;
  63.     $sql = "INSERT INTO `order_log` (content) values('$content')";
  64.     mysqli_query($con, $sql);
  65. }

3.redis 乐观锁防止超卖

  1. <?php
  2.  
  3. $redis =new Redis();
  4. $redis->connect("127.0.0.1", 6379);
  5. $redis->watch('sales');//乐观锁 监视作用 set()  初始值0
  6. $sales = $redis->get('sales');
  7.  
  8. $n = 20;// 库存
  9. if ($sales >= $n) {
  10.     exit('秒杀结束');
  11. }
  12.  
  13. //redis开启事务
  14. $redis->multi();
  15. $redis->incr('sales'); //将 key 中储存的数字值增一 ,如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
  16. $res = $redis->exec(); //成功1 失败0
  17.  
  18. if ($res) {
  19.     //秒杀成功
  20.     $con = new mysqli('localhost','root','root','test');
  21.     if (!$con) {
  22.         echo "数据库连接失败";
  23.     }
  24.  
  25.     $product_id = 1;// 商品ID
  26.     $buy_num = 1;// 购买数量
  27.     sleep(1);
  28.  
  29.     $sql = "update products set store=store-{$buy_num} where id={$product_id}";
  30.  
  31.     if (mysqli_query($con, $sql)) {
  32.         echo "秒杀完成";
  33.     }
  34.  
  35. } else {
  36.     exit('抢购失败');
  37. }

posted @ 2022-06-08 23:53  Bashuslovakia  阅读(266)  评论(0)  编辑  收藏  举报