• 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. }
  • 相关阅读:
    kvm添加磁盘
    python学习1
    ubuntu使sudo不需要密码
    磁盘挂载
    github/gitlab添加多个ssh key
    生成SSH key
    git 删除追踪状态
    angular2+ 初理解
    本地项目上传到GitHub
    new Date()之参数传递
  • 原文地址：https://www.cnblogs.com/ianlab/p/16357749.html
Copyright © 2020-2023  润新知