当前位置:首页 > PHP教程 > php高级应用 > 列表

php+redis消息队列实现抢购功能

发布:smiling 来源: PHP粉丝网  添加日期:2021-09-03 10:55:45 浏览: 评论:0 

本文实例为大家分享了php+redis消息队列实现抢购的具体代码,供大家参考,具体内容如下

实现功能:

1. 基于redis队列,防止高并发的超卖

2. 基于mysql的事务加排它锁,防止高并发的超卖

基于redis队列工作流程:

1. 管理员根据goods表中的库存,创建redis商品库存队列

2. 客户端访问秒杀API

3. web服务器先从redis的商品库存队列中查询剩余库存重点内容

4. redis队列中有剩余,则在mysql中创建订单,去库存,抢购成功

5. redis队列中没有剩余,则提示库存不足,抢购失败重点内容

基于mysql事务和排它锁工作流程:

1. 开启事务

2. 查询库存,并显示的设置写锁(排他锁):SELECT * FROM goods WHERE id = 1 FOR UPDATE

3. 生成订单

4. 去库存,隐示的设置写锁(排他锁):UPDATE goods SET counts = counts – 1 WHERE id = 1

5. commit,释放锁

注意:第二步步可以设置共享锁,不然有可能会造成死锁。

代码:

  1. <?php 
  2. /********************************************** 
  3. * 抢购模块 
  4. * 
  5. * @author liubin 
  6. * @date 2016-02-10 
  7. * 
  8. * ab -n 1000 -c 100 http://192.168.16.73/Seckill/buy.php 
  9. * 
  10. */ 
  11. class seckill extends common 
  12.  
  13.  private $_orderModel = null; 
  14.  private $_goodsModel = null; 
  15.  private $_redis = null; 
  16.  /* 
  17.   * 错误信息 
  18.  */ 
  19.  protected $_error = ''
  20.  /** 
  21.   * 构造器 
  22.   * 
  23.  */ 
  24.  public function __construct() 
  25.  { 
  26.   if($this->_orderModel === null){ 
  27.    $this->_orderModel = new OrderModel(); 
  28.   } 
  29.   if($this->_goodsModel === null){ 
  30.    $this->_goodsModel = new GoodsModel(); 
  31.   } 
  32.   if($this->_redis === null){ 
  33.    $this->_redis = new QRedis();  
  34.   } 
  35.  } 
  36.  /* 
  37.   * 秒杀API 
  38.   *  
  39.   * @author liubin 
  40.   * @date 2017-02-10 
  41.  */ 
  42.  public function addQsec(){ 
  43.   $gid = intval($_GET['gid']); 
  44.   $type = isset($_GET['type']) ? $_GET['type'] : 'mysql'
  45.   switch ($type) { 
  46.    case 'mysql'
  47.     $this->order_check_mysql($gid); 
  48.     echo $this->getError(); 
  49.     break
  50.    case 'redis'
  51.     $this->order_check_redis($gid); 
  52.     echo $this->getError(); 
  53.     break
  54.    case 'transaction'
  55.     $this->order_check_transaction($gid); 
  56.     echo $this->getError(); 
  57.     break
  58.    default
  59.     echo '类型错误'
  60.     break
  61.   } 
  62.  } 
  63.  /* 
  64.   * 获取错误信息 
  65.   *  
  66.   * @author liubin 
  67.   * @date 2017-02-10 
  68.  */ 
  69.  public function getError(){ 
  70.   return $this->_error; 
  71.  } 
  72.  /* 
  73.   * 基于mysql验证库存信息 
  74.   * @desc 高并发下会导致超卖 
  75.   * 
  76.   * @author liubin 
  77.   * @date 2017-02-10 
  78.  */ 
  79.  protected function order_check_mysql($gid){ 
  80.  
  81.  
  82.   $model = $this->_goodsModel; 
  83.   $pdo = $model->getHandler(); 
  84.   $gid = intval($gid); 
  85.  
  86.   /* 
  87.    * 1:$sql_forlock如果不加事务,不加写锁: 
  88.    * 超卖非常严重,就不说了 
  89.    *  
  90.    * 2:$sql_forlock如果不加事务,只加写锁: 
  91.    * 第一个会话读$sql_forlock时加写锁,第一个会话$sql_forlock查询结束会释放该行锁. 
  92.    * 第二个会话在第一个会话释放后读$sql_forlock的写锁时,会再次$sql_forlock查库存 
  93.    * 导致超卖现象产生 
  94.    * 
  95.   */ 
  96.   $sql_forlock = 'select * from goods where id = '.$gid .' limit 1 for update'
  97.   //$sql_forlock = 'select * from goods where id = '.$gid .' limit 1'; 
  98.   $result = $pdo->query($sql_forlock,PDO::FETCH_ASSOC); 
  99.   $goodsInfo = $result->fetch(); 
  100.  
  101.   if($goodsInfo['counts']>0){ 
  102.  
  103.    //去库存 
  104.    $gid = $goodsInfo['id']; 
  105.    $sql_inventory = 'UPDATE goods SET counts = counts - 1 WHERE id = '.$gid
  106.    $result = $this->_goodsModel->exect($sql_inventory); 
  107.    if($result){ 
  108.     //创订单 
  109.     $data    = []; 
  110.     $data['order_id'] = $this->_orderModel->buildOrderNo(); 
  111.     $data['goods_id'] = $goodsInfo['id']; 
  112.     $data['addtime'] = time(); 
  113.     $data['uid']  = 1; 
  114.     $order_rs = $this->_orderModel->create_order($data); 
  115.     if($order_rs){ 
  116.      $this->_error = '购买成功'
  117.      return true; 
  118.     } 
  119.    } 
  120.   } 
  121.  
  122.   $this->_error = '库存不足'
  123.   return false; 
  124.  
  125.  } 
  126.  /* 
  127.   * 基于redis队列验证库存信息 
  128.   * @desc Redis是底层是单线程的,命令执行是原子操作,包括lpush,lpop等.高并发下不会导致超卖 
  129.   * 
  130.   * @author liubin 
  131.   * @date 2017-02-10 
  132.  */ 
  133.  protected function order_check_redis($gid){ 
  134.   $goodsInfo = $this->_goodsModel->getGoods($gid); 
  135.   if(!$goodsInfo){ 
  136.    $this->_error = '商品不存在'
  137.    return false; 
  138.   } 
  139.   $key = 'goods_list_'.$goodsInfo['id']; 
  140.   $count = $this->_redis->getHandel()->lpop($key); 
  141.   if(!$count){ 
  142.    $this->_error = '库存不足'
  143.    return false; 
  144.   } 
  145.   //生成订单 
  146.   $data    = []; 
  147.   $data['order_id'] = $this->_orderModel->buildOrderNo(); 
  148.   $data['goods_id'] = $goodsInfo['id']; 
  149.   $data['addtime'] = time(); 
  150.   $data['uid']  = 1; 
  151.   $order_rs = $this->_orderModel->create_order($data); 
  152.  
  153.   //库存减少 
  154.   $gid = $goodsInfo['id']; 
  155.   $sql = 'UPDATE goods SET counts = counts - 1 WHERE id = '.$gid
  156.   $result = $this->_goodsModel->exect($sql); 
  157.   $this->_error = '购买成功'
  158.   return true; 
  159.  } 
  160.  /* 
  161.   * 基于mysql事务验证库存信息 
  162.   * @desc 事务 和 行锁 模式,高并发下不会导致超卖,但效率会慢点 
  163.   * @author liubin 
  164.   * @date 2017-02-10 
  165.  
  166.  
  167.   说明: 
  168.   如果$sql_forlock不加写锁,并发时,$sql_forlock查询的记录存都大于0,可以减库存操作. 
  169.   如果$sql_forlock加了写锁,并发时,$sql_forlock查询是等待第一次链接释放后查询.所以库存最多就是5 
  170.  
  171.  */ 
  172.  protected function order_check_transaction($gid){ 
  173.  
  174.   $model = $this->_goodsModel; 
  175.   $pdo = $model->getHandler(); 
  176.   $gid = intval($gid); 
  177.  
  178.   try{ 
  179.    $pdo->beginTransaction();//开启事务处理 
  180.  
  181.  
  182.    /* 
  183.     * 1:$sql_forlock如果只加事务,不加写锁: 
  184.     * 开启事务 
  185.     * 因为没有加锁,读$sql_forlock后,并发时$sql_inventory之前还可以再读。 
  186.     * $sql_inventory之后和commit之前才会锁定 
  187.     * 出现超卖跟事务的一致性不冲突 
  188.     *  
  189.     * 
  190.     * 2:$sql_forlock如果加了事务,又加读锁: 
  191.     * 开启事务 
  192.     * 第一个会话读$sql_forlock时加读锁,并发时,第二个会话也允许获得$sql_forlock的读锁, 
  193.     * 但是在第一个会话执行去库存操作时(写锁),写锁便会等待第二个会话的读锁,第二个会话执行写操作时,写锁便会等待第一个会话的读锁, 
  194.     * 出现死锁 
  195.  
  196.     * 3:$sql_forlock如果加了事务,又加写锁: 
  197.     * 开启事务 
  198.     * 第一个会话读$sql_forlock时加写锁,直到commit才会释放写锁,并发查询不会出现超卖现象。 
  199.     * 
  200.    */ 
  201.  
  202.    $sql_forlock = 'select * from goods where id = '.$gid .' limit 1 for update'
  203.    //$sql_forlock = 'select * from goods where id = '.$gid .' limit 1 LOCK IN SHARE MODE'; 
  204.    //$sql_forlock = 'select * from goods where id = '.$gid .' limit 1'; 
  205.    $result = $pdo->query($sql_forlock,PDO::FETCH_ASSOC); 
  206.    $goodsInfo = $result->fetch(); 
  207.  
  208.    if($goodsInfo['counts']>0){ 
  209.  
  210.     //去库存 
  211.     $gid = $goodsInfo['id']; 
  212.     $sql_inventory = 'UPDATE goods SET counts = counts - 1 WHERE id = '.$gid
  213.     $result = $this->_goodsModel->exect($sql_inventory); 
  214.  
  215.     if(!$result){ 
  216.      $pdo->rollBack(); 
  217.      $this->_error = '库存减少失败'
  218.      return false; 
  219.     } 
  220.  
  221.     //创订单 
  222.     $data    = []; 
  223.     $data['id']   = 'null'
  224.     $data['order_id'] = $this->_orderModel->buildOrderNo(); 
  225.     $data['goods_id'] = $goodsInfo['id']; 
  226.     $data['uid']  = 'abc'
  227.     $data['addtime'] = time(); 
  228.  
  229.     $sql = 'insert into orders (id,order_id,goods_id,uid,addtime) values ('.$data['id'].',"'.$data['order_id'].'","'.$data['goods_id'].'","'.$data['uid'].'","'.$data['addtime'].'")';    
  230.     $result = $pdo->exec($sql); 
  231.     if(!$result){ 
  232.      $pdo->rollBack(); 
  233.      $this->_error = '订单创建失败'
  234.      return false; 
  235.     } 
  236.     $pdo->commit();//提交 
  237.     $this->_error = '购买成功'
  238.     return true; 
  239.  
  240.    }else
  241.     $this->_error = '库存不足'
  242.     return false; 
  243.    } 
  244.   }catch(PDOException $e){ 
  245.    echo $e->getMessage(); 
  246.    $pdo->rollBack(); 
  247.   } 
  248.  
  249.  
  250.  } 
  251.  /* 
  252.   * 创建订单 
  253.   * mysql 事物处理,也可以用存储过程 
  254.   * 
  255.  */ 
  256.  private function create_order($goodsInfo){ 
  257.   //生成订单 
  258.   $data    = []; 
  259.   $data['order_id'] = $this->_orderModel->buildOrderNo(); 
  260.   $data['goods_id'] = $goodsInfo['id']; 
  261.   $data['addtime'] = time(); 
  262.   $data['uid']  = 1; 
  263.   $order_rs = $this->_orderModel->create_order($data); 
  264.  
  265.   //库存减少 
  266.   $gid = $goodsInfo['id']; 
  267.   $sql = 'UPDATE goods SET counts = counts - 1 WHERE id = '.$gid
  268.   $result = $this->_goodsModel->exect($sql); 
  269.   return true; 
  270.  } 
  271. }

Tags: PHP+Redis 消息队列

分享到: