Redis+Lua解决万/s 级别抢红包方案-CSDN博客

2019独角兽企业重金招聘Python工程师标准>>>

https://github.com/ZhuBaker/redis-lua

一、技术方案

说到抢红包，我们肯定会想到拆红包和抢红包两个业务场景，拆红包是指将制定金额拆分为指定数目的红包的过程，即用来确定每个红包的金额，抢红包是典型的高并发场景，需要放置红包超发的情况。

红包拆分：

1.实施拆分

实时拆分，是指在抢红包时，实时计算每个红包的金额，以实现红包拆分的过程。过程对系统性能，和拆分算法要求较高，例如拆分过程需要保证后续拆分红包的金额不为空，不容易做到拆分红包的金额服从正态分布。

2.预先拆分

预先生成，指的是红包在开抢之前已经完成了红包的拆分工作，抢红包的过程实际上是依次取出拆分好的红包金额，对拆分算法要求较低，可以拆分出随机性较好的红包金额，通常需要结合队列来进行使用。

拆分算法

现在还并没有找到业界通用的算法，但红包拆分算法应该是拆分金额要看起来随机，最好能够服从正态分布，可以参考微信或者@lcode提供的红包拆分算法。

微信拆分算法的优点是算法较为简单，拆分效率高，同事由于该算法天然的特性，能够保证后续红包金额一定不为空，特别适合实时拆分的场景，但缺点是会导致大额红包较大概率地在拆分的最后出现。@lcode拆分算法的有点是拆分金额基本符合正态分布，适合随机性要求较高的红包拆分场景。

我们的方案

çº¢åå ææµç¨å¾

如果对红包拆分的随机性要求不高，但是对系统的可靠性要求较高，我们选用预生成方式，使用二倍均值的红包拆分算法，作为我们的红包拆分方案。

采用预生成方式，我们先把预生成的红包放入Redis的List中，当抢红包时只是Pop List即可，具体实现将在下面介绍。

拆分算法可以描述为：假设剩余拆分金额为M , 剩余拆分红包个数为N , 红包最小金额为1元，红包最小单位为元，那么定义当前红包的金额为：

m=rand(1,floor(M/N∗2))

其中floor向下取整， rand(min,max)表示从[min,max] 区间随机一个值，M/N*2 标识剩余平均金额的两倍，因为N >=2 ,所以 M/N*2 < M , 表示一定能保证后续的红包拆分到金额。

Java实现：

package com.qf58.exec.redpackage;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Created with IntelliJ IDEA.
 *
 * @author: zhubo
 * @description: 红包拆分工具类
 * @time: 2018年06月07日
 * @modifytime:
 */
public class RadPackageUtils {

    private static final Random random = new Random();

    /**
     * 拆分核心算法
     * @param num 拆分红包个数
     * @param sumMoney 总金额
     * @return
     */
    public static List<Integer> getPackage(Integer num , Integer sumMoney){
        List<Integer> pak = new ArrayList<>();
        while(num > 1){
            Integer m = getMoney(num,sumMoney);
            num -- ;
            sumMoney -= m;
            pak.add(m);
        }
        pak.add(sumMoney);
        return pak;
    }

    private static Integer getMoney(Integer num , Integer restMoney){
        int floor = (int)Math.floor(restMoney * 1.0d / num * 2);
        return getRandom(1,floor);
    }

    public static Integer getRandom(Integer min,Integer max){
        int i = random.nextInt(max - min + 1) + min;
        return i;
    }

    public static void main(String[] args) {
        List<Integer> aPackage = getPackage(1000, 50000000);
        System.out.println(aPackage.size());
        Integer j = 0;
        for (Integer i : aPackage){
            j = j + i;
        }
        System.out.println(j);
        System.out.println(aPackage);
    }
}

值得一提的是，我们为了保证红包金额差异尽量小，先将总金额平均拆分成 N+1 份，将第 N+1 份红包按照上述的红包拆分算法拆分成 N 份，这 N 份红包加上之前的平均金额才作为最终的红包金额。

红包占有流程图如下：

çº¢åå ææµç¨å¾

其中，red::list为 List 结构，存放预先生成的红包金额（流程①中的红包队列）；red::task也为 List 结构，红包异步发放队列（流程②中的任务队列）；red::draw为 Hash 结构，存放红包领取记录，key 为用户的 openid，value为序列化的红包信息；red::draw_count:u:openid为 k-v 结构，用户领取红包计数器。

下面，我将以以下 3 个问题为中心，来说说我们设计出的抢红包系统。

1.如何保证不超发

我们需要保证红包的占有过程，从红包占有的流程图中可以看出，这个过程是很多key操作的组合，那么怎么保证原子性？可以使用redis事物，但我们选用了lua方案，一方面是因为首先要保证性能，而lua脚本嵌入 redis执行不存在性能瓶颈，另一方面lua脚本在执行时本身就是原子的，满足需求，并且 lua脚本内部可以写逻辑。

红包占有的Lua 脚本实现如下：

-- 抢红包脚本
--[[
--red:list 为 List 结构，存放预先生成的红包金额
red:draw_count:u:openid 为 k-v 结构，用户领取红包计数器
red:draw为 Hash 结构，存放红包领取记录
red:task 也为 List 结构，红包异步发放队列
openid 为用户的openid
]]--
local openid = KEYS[1]
local isDraw = redis.call("HEXISTS","red:draw",openid)
-- 已经领取
if isDraw ~= 0 then
    return true
end
-- 领取太多次了
local times = redis.call("INCR","red:draw_count:u:"..openid)
if times and tonumber(times) > 9 then
    return 0
end
local number = redis.call("RPOP","red:list")
-- 没有红包
if not number then
    return {}
end
-- 领取人昵称为Fhb,头像为 https:// xxxxxx
local red = {money=number,name=KEYS[2] , pic = KEYS[3] }
-- 领取记录
redis.call("HSET","red:draw",openid,cjson.encode(red))
-- 处理队列
red["openid"] = openid
redis.call("RPUSH","red:task",cjson.encode(red))

return true