Redis迷你版微信搶紅包實戰(zhàn)

更新時間：2025年05月25日 11:37:40 作者：NPE~

本文主要介紹了Redis迷你版微信搶紅包實戰(zhàn)

1 思路分析

搶紅包是一個高并發(fā)操作，且我們需要保證其原子性，同時搶紅包過程中不能加鎖，不能出現因為某個人網絡卡頓，導致其他人無法搶紅包??。

1.1 流程

搶紅包流程：發(fā)紅包-拆紅包-搶紅包-記錄誰搶了紅包

發(fā)紅包：提供接口send，參數：紅包總金額，紅包個數。拆完之后通過redis list結構將紅包存入redis
拆紅包：split接口，根據算法將紅包合理的拆分，金額不能差距太大，比如：一個100元紅包，拆分為20個，不能出現一個紅包里就包含99元的情況
搶紅包：提供rob接口，接收紅包名（要搶哪個紅包，不同人不同群發(fā)的紅包都是唯一的），接收用戶id（誰搶）
記錄：搶完紅包之后，記錄用戶id與所搶紅包??對應關系，防止多搶。通過redis hset數據結構實現。

1.2 注意點

①拆紅包：二倍均值算法

二倍均值算法：每次拆分后塞進子紅包的金額 = 隨機區(qū)間(0, (剩余紅包金額M / 未被搶的剩余紅包個數N) * 2)

保證被拆紅包金額的差距不會太大。不會出現一個100元紅包，拆分為20個，一個紅包里就包含99元的情況

②發(fā)紅包：list

記錄紅包被拆分為了多少份，并且每份里有多少錢

③搶紅包&記錄：hset

記錄用戶與被搶紅包的對應關系，防止多搶

2 代碼實現

為了大家能看得清晰，這里我直接將所有代碼都放在了main.go，實際使用和實現還是應該拆分為service、controller…

2.1 拆紅包splitRedPacket

// 拆紅包
func splitRedPacket(totalMoney, totalNum int) []int {
	//1. 將紅包拆分為幾個
	redpackets := make([]int, totalNum)
	usedMoney := 0
	for i := 0; i < totalNum; i++ {
		//最后一個紅包，還剩余多少就分多少
		if i == totalNum-1 {
			redpackets[i] = totalMoney - usedMoney
		} else {
			//二倍均值算法：每次拆分后塞進子紅包的金額 = 隨機區(qū)間(0, (剩余紅包金額M / 未被搶的剩余紅包個數N) * 2)
			avgMoney := ((totalMoney - usedMoney) / (totalNum - i)) * 2
			money := 1 + rand.Intn(avgMoney-1)
			redpackets[i] = money
			usedMoney += money
		}
	}
	return redpackets
}

2.2 發(fā)紅包sendRedPacket

// 發(fā)紅包 http://localhost:9090/send?totalMoney=100&totalNum=3
func sendRedPacket(c *context2.Context) {
	money, _ := c.URLParamInt("totalMoney")
	totalNum, _ := c.URLParamInt("totalNum")
	redPackets := splitRedPacket(money, totalNum)
	uuid, _ := uuid.NewUUID()
	k := RED_PACKGE_KEY + uuid.String()
	for _, r := range redPackets {
		_, err := RedisCli.LPush(context.TODO(), k, r).Result()
		if err != nil && err != redis.Nil {
			panic(err)
		}
	}
	c.JSON(fmt.Sprintf("send redpacket[%s] succ %v", k, redPackets))
}

2.3 搶紅包&記錄robRedPacket

// 搶紅包 http://localhost:9090/rob?redPacket=e3e71f56-e9a3-11ee-9ad5-7a2cb90a4104&uId=4
func robRedPacket(c *context2.Context) {
	//判斷是否搶過
	redPacket := c.URLParam("redPacket")
	uId, _ := c.URLParamInt("uId")
	exists, err := RedisCli.HExists(context.TODO(), RED_PACKAGE_CONSUME_KEY+redPacket, fmt.Sprintf("%d", uId)).Result()
	if err != nil && err != redis.Nil {
		panic(err)
	}
	if exists {
		//表明已經搶過
		c.JSON(fmt.Sprintf("[%d] you have already rob", uId))
		return
	} else if !exists {
		//從list里取出一個紅包
		result, err := RedisCli.LPop(context.TODO(), RED_PACKGE_KEY+redPacket).Result()
		if err == redis.Nil {
			//紅包已經搶完了
			c.JSON(fmt.Sprintf("redpacket is empty"))
			return
		}
		if err != nil {
			panic(err)
		}
		fmt.Printf("%d rob the red packet %v\n", uId, result)
		//記錄：后續(xù)可以異步進MySQL或者MQ做統(tǒng)計分析，每一年搶了多少紅包，金額是多少【年度總結】
		_, err = RedisCli.HSet(context.TODO(), RED_PACKAGE_CONSUME_KEY+redPacket, uId, result).Result()
		if err != nil && err != redis.Nil {
			panic(err)
		}
		c.JSON(fmt.Sprintf("[%d] rob the red packet %v", uId, result))
	}

}

2.4 分析（紅包被誰搶了）infoRedPacket

func infoRedPacket(c *context2.Context) {
	redPacket := c.URLParam("redPacket")
	infoMap, err := RedisCli.HGetAll(context.TODO(), RED_PACKAGE_CONSUME_KEY+redPacket).Result()
	if err != nil && err != redis.Nil {
		panic(err)
	}
	c.JSON(infoMap)
}

全部代碼

Github：
https://github.com/ziyifast/ziyifast-code_instruction/tree/main/redis_demo/redpacket_demo

package main

import (
	"context"
	"fmt"
	"github.com/go-redis/redis/v8"
	"github.com/google/uuid"
	"github.com/kataras/iris/v12"
	context2 "github.com/kataras/iris/v12/context"
	"math/rand"
	"time"
)

/*
通過redis實現迷你版微信搶紅包
1. 發(fā)紅包
2. 拆紅包（一個紅包拆分成多少個，每個紅包里有多少錢）=》二倍均值算法，將拆分后的紅包通過list放入redis
3. 搶紅包（用戶搶紅包，并記錄哪個用戶搶了多少錢，防止重復搶）：hset記錄每個紅包被哪些用戶搶了
*/
var (
	RedisCli                *redis.Client
	RED_PACKGE_KEY          = "redpackage:"
	RED_PACKAGE_CONSUME_KEY = "redpackage:consume:"
)

func init() {
	rand.Seed(time.Now().UnixNano())
	RedisCli = redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		DB:   0,
	})
}

func main() {
	app := iris.New()
	app.Get("/send", sendRedPacket)
	app.Get("/rob", robRedPacket)
	app.Get("/info", infoRedPacket)
	app.Listen(":9090", nil)
}

// 發(fā)紅包 http://localhost:9090/send?totalMoney=100&totalNum=3
func sendRedPacket(c *context2.Context) {
	money, _ := c.URLParamInt("totalMoney")
	totalNum, _ := c.URLParamInt("totalNum")
	redPackets := splitRedPacket(money, totalNum)
	uuid, _ := uuid.NewUUID()
	k := RED_PACKGE_KEY + uuid.String()
	for _, r := range redPackets {
		_, err := RedisCli.LPush(context.TODO(), k, r).Result()
		if err != nil && err != redis.Nil {
			panic(err)
		}
	}
	c.JSON(fmt.Sprintf("send redpacket[%s] succ %v", k, redPackets))
}

// 搶紅包 http://localhost:9090/rob?redPacket=e3e71f56-e9a3-11ee-9ad5-7a2cb90a4104&uId=4
func robRedPacket(c *context2.Context) {
	//判斷是否搶過
	redPacket := c.URLParam("redPacket")
	uId, _ := c.URLParamInt("uId")
	exists, err := RedisCli.HExists(context.TODO(), RED_PACKAGE_CONSUME_KEY+redPacket, fmt.Sprintf("%d", uId)).Result()
	if err != nil && err != redis.Nil {
		panic(err)
	}
	if exists {
		//表明已經搶過
		c.JSON(fmt.Sprintf("[%d] you have already rob", uId))
		return
	} else if !exists {
		//從list里取出一個紅包
		result, err := RedisCli.LPop(context.TODO(), RED_PACKGE_KEY+redPacket).Result()
		if err == redis.Nil {
			//紅包已經搶完了
			c.JSON(fmt.Sprintf("redpacket is empty"))
			return
		}
		if err != nil {
			panic(err)
		}
		fmt.Printf("%d rob the red packet %v\n", uId, result)
		//記錄：后續(xù)可以異步進MySQL或者MQ做統(tǒng)計分析，每一年搶了多少紅包，金額是多少【年度總結】
		_, err = RedisCli.HSet(context.TODO(), RED_PACKAGE_CONSUME_KEY+redPacket, uId, result).Result()
		if err != nil && err != redis.Nil {
			panic(err)
		}
		c.JSON(fmt.Sprintf("[%d] rob the red packet %v", uId, result))
	}

}

func infoRedPacket(c *context2.Context) {
	redPacket := c.URLParam("redPacket")
	infoMap, err := RedisCli.HGetAll(context.TODO(), RED_PACKAGE_CONSUME_KEY+redPacket).Result()
	if err != nil && err != redis.Nil {
		panic(err)
	}
	c.JSON(infoMap)
}

// 拆紅包
func splitRedPacket(totalMoney, totalNum int) []int {
	//1. 將紅包拆分為幾個
	redpackets := make([]int, totalNum)
	usedMoney := 0
	for i := 0; i < totalNum; i++ {
		//最后一個紅包，還剩余多少就分多少
		if i == totalNum-1 {
			redpackets[i] = totalMoney - usedMoney
		} else {
			//二倍均值算法：每次拆分后塞進子紅包的金額 = 隨機區(qū)間(0, (剩余紅包金額M / 未被搶的剩余紅包個數N) * 2)
			avgMoney := ((totalMoney - usedMoney) / (totalNum - i)) * 2
			money := 1 + rand.Intn(avgMoney-1)
			redpackets[i] = money
			usedMoney += money
		}
	}
	return redpackets
}