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

 本文内容

• 行使Redis优化高并发场景下的接口机能
• 数据库乐观锁

跟着双11的邻近，各类促销勾当开始变得热点起来，较量主流的有秒杀、抢优惠券、拼团等等。

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

条件

勾当法则

• 奖品数目有限，好比100个
• 不限定参加用户数
• 每个用户只能参加1次秒杀

勾当要求

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

数据库实现

气馁锁机能太差，本文不予接头，接头一下行使乐观锁办理高并发题目的优弱点。

数据库布局

• 未中奖时UserId为0，RewardAt为NULL
• 中奖时UserId为中奖用户ID，RewardAt为中奖时刻

乐观锁实现

乐观锁现实上并不存在真正的锁，乐观锁是操作数据的某个字段来做的，好比本文的例子就是以UserId来实现的。

实现流程如下：

1.查询UserId为0的奖品，假如未找到则提醒无奖品

SELECT * FROM envelope WHERE user_id=0 LIMIT 1 

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

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语法发放奖品

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对付高并发体系的机能晋升长短常大的!接入本钱也不算高，值得进修!

尝试代码

// main.go 
package main 
 
import ( 
    "fmt" 
    "github.com/go-redis/redis" 
    _ "github.com/go-sql-driver/mysql" 
    "github.com/jinzhu/gorm" 
    "log" 
    "net/http" 
    "strconv" 
    "time" 
) 
 
type Envelope struct { 
    Id        int `gorm:"primary_key"` 
    Code      string 
    UserId    int 
    CreatedAt time.Time 
    RewardAt  *time.Time 
} 
 
func (Envelope) TableName() string { 
    return "envelope" 
} 
 
func (p *Envelope) BeforeCreate() error { 
    p.CreatedAt = time.Now() 
    return nil 
} 
 
const ( 
    QueueEnvelope = "envelope" 
    QueueUser     = "user" 
) 
 
var ( 
    db          *gorm.DB 
    redisClient *redis.Client 
) 
 
func init() { 
    var err error 
    db, err = gorm.Open("mysql", "root:root@tcp(localhost:3306)/test?charset=utf8&parseTime=True&loc=Local") 
    if err != nil { 
        log.Fatal(err) 
    } 
    if err = db.DB().Ping(); err != nil { 
        log.Fatal(err) 
    } 
    db.DB().SetMaxOpenConns(100) 
    fmt.Println("database connected. pool size 10") 
} 
 
func init() { 
    redisClient = redis.NewClient(&redis.Options{ 
        Addr:     "localhost:6379", 
        DB:       0, 
        PoolSize: 100, 
    }) 
    if _, err := redisClient.Ping().Result(); err != nil { 
        log.Fatal(err) 
    } 
    fmt.Println("redis connected. pool size 100") 
} 
 
// 读取Code写入Queue 
func init() { 
    envelopes := make([]Envelope, 0, 100) 
    if err := db.Debug().Where("user_id=0").Limit(100).Find(&envelopes).Error; err != nil { 
        log.Fatal(err) 
    } 
    if len(envelopes) != 100 { 
        log.Fatal("不敷100个奖品") 
    } 
    for i := range envelopes { 
        if err := redisClient.LPush(QueueEnvelope, envelopes[i].Code).Err(); err != nil { 
            log.Fatal(err) 
        } 
    } 
    fmt.Println("load 100 envelopes") 
} 
 
func main() { 
    http.HandleFunc("/envelope", func(w http.ResponseWriter, r *http.Request) { 
        uid := r.Header.Get("x-user-id") 
        if uid == "" { 
            w.WriteHeader(401) 
            _, _ = fmt.Fprint(w, "UnAuthorized") 
            return 
        } 
        uidValue, err := strconv.Atoi(uid) 
        if err != nil { 
            w.WriteHeader(400) 
            _, _ = fmt.Fprint(w, "Bad Request") 
            return 
        } 
        // 检测用户是否抢过了 
        if result, err := redisClient.HIncrBy(QueueUser, uid, 1).Result(); err != nil || result != 1 { 
            w.WriteHeader(429) 
            _, _ = fmt.Fprint(w, "Too Many Request") 
            return 
        } 
        // 检测是否在行列中 
        code, err := redisClient.LPop(QueueEnvelope).Result() 
        if err != nil { 
            w.WriteHeader(200) 
            _, _ = fmt.Fprint(w, "No Envelope") 
            return 
        } 
        // 发放红包 
        envelope := &Envelope{} 
        err = db.Where("code=?", code).Take(&envelope).Error 
        if err == gorm.ErrRecordNotFound { 
            w.WriteHeader(200) 
            _, _ = fmt.Fprint(w, "No Envelope") 
            return 
        } 
        if err != nil { 
            w.WriteHeader(500) 
            _, _ = fmt.Fprint(w, err) 
            return 
        } 
        now := time.Now() 
        envelope.UserId = uidValue 
        envelope.RewardAt = &now 
        rowsAffected := db.Where("user_id=0").Save(&envelope).RowsAffected // 添加user_id=0来验证Redis是否真的办理争抢题目 
        if rowsAffected == 0 { 
            fmt.Printf("产生争抢. id=%dn", envelope.Id) 
            w.WriteHeader(500) 
            _, _ = fmt.Fprintf(w, "产生争抢. id=%dn", envelope.Id) 
            return 
        } 
        _, _ = fmt.Fprint(w, envelope.Code) 
    }) 
 
    fmt.Println("listen on 8080") 
    fmt.Println(http.ListenAndServe(":8080", nil)) 
} 

（编辑：湖南网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!