Redis优化高并发下的秒杀性能

Redis优化高并发下的秒杀性能

随着双11的临近,各种促销活动开始变得热门起来,比较主流的有秒杀、抢优惠券、拼团等等。

涉及到高并发争抢同一个资源的主要场景有秒杀和抢优惠券。

前提

活动规则

  • 奖品数量有限,比如100个
  • 不限制参与用户数
  • 每个用户只能参与1次秒杀

活动要求

  • 不能多发,也不能少发,100个奖品要全部发出去
  • 1个用户最多抢1个奖品
  • 遵循先到先得原则,先来的用户有奖品

数据库实现

悲观锁性能太差,本文不予讨论,讨论一下使用乐观锁解决高并发问题的优缺点。

数据库结构

Redis优化高并发下的秒杀性能

  • 未中奖时UserId为0,RewardAt为NULL
  • 中奖时UserId为中奖用户ID,RewardAt为中奖时间

乐观锁实现

乐观锁实际上并不存在真正的锁,乐观锁是利用数据的某个字段来做的,比如本文的例子就是以UserId来实现的。

实现流程如下:

1.查询UserId为0的奖品,如果未找到则提示无奖品

  1. SELECT * FROM envelope WHERE user_id=0 LIMIT 1

2.更新奖品的用户ID和中奖时间(假设奖品ID为1,中奖用户ID为100,当前时间为2019-10-29 12:00:00),这里的user_id=0就是我们的乐观锁了。

  1. UPDATE envelope SET user_id=100, reward_at=‘2019-10-29 12:00:00’ WHERE user_id=0 AND id=1

3.检测UPDATE语句的执行返回值,如果返回1证明中奖成功,否则证明该奖品被其他人抢了

为什么要添加乐观锁

正常情况下获取奖品、然后把奖品更新给指定用户是没问题的。如果不添加user_id=0时,高并发场景下会出现下面的问题:

  1. 两个用户同时查询到了1个未中奖的奖品(发生并发问题)
  2. 将奖品的中奖用户更新为用户1,更新条件只有ID=奖品ID
  3. 上述SQL执行是成功的,影响行数也是1,此时接口会返回用户1中奖
  4. 接下来将中奖用户更新为用户2,更新条件也只有ID=奖品ID
  5. 由于是同一个奖品,已经发给用户1的奖品会重新发放给用户2,此时影响行数为1,接口返回用户2也中奖
  6. 所以该奖品的最终结果是发放给用户2
  7. 用户1就会过来投诉活动方了,因为抽奖接口返回用户1中奖,但他的奖品被抢了,此时活动方只能赔钱了

添加乐观锁之后的抽奖流程

  1. 更新用户1时的条件为id=红包ID AND user_id=0 ,由于此时红包未分配给任何人,用户1更新成功,接口返回用户1中奖
  2. 当更新用户2时更新条件为id=红包ID AND user_id=0,由于此时该红包已经分配给用户1了,所以该条件不会更新任何记录,接口返回用户2中奖

乐观锁优缺点

优点

  • 性能尚可,因为无锁
  • 不会超发

缺点

  • 通常不满足“先到先得”的活动规则,一旦发生并发,就会发生未中奖的情况,此时奖品库还有奖品

压测

在MacBook Pro 2018上的压测表现如下(Golang实现的HTTP服务器,MySQL连接池大小100,Jmeter压测):

  • 500并发 500总请求数 平均响应时间331ms 发放成功数为31 吞吐量458.7/s

Redis实现

可以看到乐观锁的实现下争抢比太高,不是推荐的实现方法,下面通过Redis来优化这个秒杀业务。

Redis高性能的原因

  • 单线程 省去了线程切换开销
  • 基于内存的操作 虽然持久化操作涉及到硬盘访问,但是那是异步的,不会影响Redis的业务
  • 使用了IO多路复用

实现流程

1.活动开始前将数据库中奖品的code写入Redis队列中

2.活动进行时使用lpop弹出队列中的元素

3.如果获取成功,则使用UPDATE语法发放奖品

  1. UPDATE reward SET user_id=用户ID,reward_at=当前时间 WHERE code=‘奖品码’

4.如果获取失败,则当前无可用奖品,提示未中奖即可

使用Redis的情况下并发访问是通过Redis的lpop()来保证的,该方法是原子方法,可以保证并发情况下也是一个个弹出的。

压测

在MacBook Pro 2018上的压测表现如下(Golang实现的HTTP服务器,MySQL连接池大小100,Redis连接池代销100,Jmeter压测):

  • 500并发 500总请求数 平均响应时间48ms 发放成功数100 吞吐量497.0/s

结论

可以看到Redis的表现是稳定的,不会出现超发,且访问延迟少了8倍左右,吞吐量还没达到瓶颈,可以看出Redis对于高并发系统的性能提升是非常大的!接入成本也不算高,值得学习!

实验代码

  1. // main.go
  2. package main
  3. import (
  4.     “fmt”
  5.     “github.com/go-redis/redis”
  6.     _ “github.com/go-sql-driver/mysql”
  7.     “github.com/jinzhu/gorm”
  8.     “log”
  9.     “net/http”
  10.     “strconv”
  11.     “time”
  12. )
  13. type Envelope struct {
  14.     Id        int `gorm:“primary_key”`
  15.     Code      string
  16.     UserId    int
  17.     CreatedAt time.Time
  18.     RewardAt  *time.Time
  19. }
  20. func (Envelope) TableName() string {
  21.     return “envelope”
  22. }
  23. func (p *Envelope) BeforeCreate() error {
  24.     p.CreatedAt = time.Now()
  25.     return nil
  26. }
  27. const (
  28.     QueueEnvelope = “envelope”
  29.     QueueUser     = “user”
  30. )
  31. var (
  32.     db          *gorm.DB
  33.     redisClient *redis.Client
  34. )
  35. func init() {
  36.     var err error
  37.     db, err = gorm.Open(“mysql”“root:root@tcp(localhost:3306)/test?charset=utf8&parseTime=True&loc=Local”)
  38.     if err != nil {
  39.         log.Fatal(err)
  40.     }
  41.     if err = db.DB().Ping(); err != nil {
  42.         log.Fatal(err)
  43.     }
  44.     db.DB().SetMaxOpenConns(100)
  45.     fmt.Println(“database connected. pool size 10”)
  46. }
  47. func init() {
  48.     redisClient = redis.NewClient(&redis.Options{
  49.         Addr:     “localhost:6379”,
  50.         DB:       0,
  51.         PoolSize: 100,
  52.     })
  53.     if _, err := redisClient.Ping().Result(); err != nil {
  54.         log.Fatal(err)
  55.     }
  56.     fmt.Println(“redis connected. pool size 100”)
  57. }
  58. // 读取Code写入Queue
  59. func init() {
  60.     envelopes := make([]Envelope, 0, 100)
  61.     if err := db.Debug().Where(“user_id=0”).Limit(100).Find(&envelopes).Error; err != nil {
  62.         log.Fatal(err)
  63.     }
  64.     if len(envelopes) != 100 {
  65.         log.Fatal(“不足100个奖品”)
  66.     }
  67.     for i := range envelopes {
  68.         if err := redisClient.LPush(QueueEnvelope, envelopes[i].Code).Err(); err != nil {
  69.             log.Fatal(err)
  70.         }
  71.     }
  72.     fmt.Println(“load 100 envelopes”)
  73. }
  74. func main() {
  75.     http.HandleFunc(“/envelope”, func(w http.ResponseWriter, r *http.Request) {
  76.         uid := r.Header.Get(“x-user-id”)
  77.         if uid == “” {
  78.             w.WriteHeader(401)
  79.             _, _ = fmt.Fprint(w, “UnAuthorized”)
  80.             return
  81.         }
  82.         uidValue, err := strconv.Atoi(uid)
  83.         if err != nil {
  84.             w.WriteHeader(400)
  85.             _, _ = fmt.Fprint(w, “Bad Request”)
  86.             return
  87.         }
  88.         // 检测用户是否抢过了
  89.         if result, err := redisClient.HIncrBy(QueueUser, uid, 1).Result(); err != nil || result != 1 {
  90.             w.WriteHeader(429)
  91.             _, _ = fmt.Fprint(w, “Too Many Request”)
  92.             return
  93.         }
  94.         // 检测是否在队列中
  95.         code, err := redisClient.LPop(QueueEnvelope).Result()
  96.         if err != nil {
  97.             w.WriteHeader(200)
  98.             _, _ = fmt.Fprint(w, “No Envelope”)
  99.             return
  100.         }
  101.         // 发放红包
  102.         envelope := &Envelope{}
  103.         err = db.Where(“code=?”, code).Take(&envelope).Error
  104.         if err == gorm.ErrRecordNotFound {
  105.             w.WriteHeader(200)
  106.             _, _ = fmt.Fprint(w, “No Envelope”)
  107.             return
  108.         }
  109.         if err != nil {
  110.             w.WriteHeader(500)
  111.             _, _ = fmt.Fprint(w, err)
  112.             return
  113.         }
  114.         now := time.Now()
  115.         envelope.UserId = uidValue
  116.         envelope.RewardAt = &now
  117.         rowsAffected := db.Where(“user_id=0”).Save(&envelope).RowsAffected // 添加user_id=0来验证Redis是否真的解决争抢问题
  118.         if rowsAffected == 0 {
  119.             fmt.Printf(“发生争抢. id=%d\n”, envelope.Id)
  120.             w.WriteHeader(500)
  121.             _, _ = fmt.Fprintf(w, “发生争抢. id=%d\n”, envelope.Id)
  122.             return
  123.         }
  124.         _, _ = fmt.Fprint(w, envelope.Code)
  125.     })
  126.     fmt.Println(“listen on 8080”)
  127.     fmt.Println(http.ListenAndServe(“:8080”, nil))
  128. }

 

极牛网精选文章《Redis优化高并发下的秒杀性能》文中所述为作者独立观点,不代表极牛网立场。如若转载请注明出处:https://geeknb.com/8336.html

(33)
打赏 微信公众号 微信公众号 微信小程序 微信小程序
上一篇 2019年10月30日 下午3:22
下一篇 2019年10月30日 下午9:19

相关推荐

发表回复

登录后才能评论
扫码关注
扫码关注
分享本页
返回顶部