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

redis高并发抽奖

代码有点缭乱，没时间整理，如果有误还请留言斧正。现在进入正题。

一、思路

1.奖品：

奖品分为奖品id(编号)、count(数量)、pointVal(价值)、remainCount (剩余数量)分为四个参数组成。

2.概率规则：

单个产品剩余数量/总产品剩余数量=单个产品概率*1000，这也就意味着每个奖品的概率都是随着数量变化的，这时候计算概率对数据在时间维度要求必须一致（数据快照）。

每个产品概率相加=1000，如果没有等于1*概率相乘的数说明数据快照有问题（我这里是乘1000所以等于1000）。

3.设计思路：

这个demo，我用的是取之于民用之于民的想法写的，保证每一个人都会中奖。是不是很开心？？？。首先我们得有甲乙双发，甲方就是抽奖系统的提供方，乙方就是我们这些抽奖的小百姓。甲方会先提供奖品出来，我这里是一，二，三，四奖项，有一个默认五等奖奖项（demo里面有一，二，三，四，五个奖项）。我会先计算甲方提供每个奖品的数量、价值然后计算所有奖品的总价值，然后用  总价值/每次抽奖的分数=总抽奖次数。总抽奖次数 - 每个奖品的 = 默认五等奖次数。这样我们就算出了所有奖品的数量（包括默认五等奖也就是安慰奖的次数）。没当抽奖总次数==0的时候就会自动轮询补充库存开始新的一轮抽奖。

中奖公式 ：
                总抽奖消耗积分上限值/每次抽奖消耗固定积分 = 总抽奖次数 
                总抽奖次数 - 已经抽奖数量 = 剩余抽奖次数 
                奖品类型 * 奖品数量 = 奖品总数量
                奖品总数量 - 已中奖数量 = 剩余奖品数量
                剩余抽奖次数/剩余奖品数量 = 剩余奖品中奖概率

详细算法可以看看这篇文章。

4.降级问题：

这个一开始我也考虑过使用降级处理，以防服务器并发过大GG。不过我考虑到跟我的设计思路不符合，会影响到概率的公平性，我就把那部分去掉了(如果你们项目需要可以自己进行降级，限流，不过这会损失一部分概率的公平性，直接导致的结果就真正的奖品往往都是在最后面出现)。

5.注意事项：

特别强调一点，每次轮询的时候判断数量一定要用 == 不用用 <=  周末吃过这个亏，结果看轮询数据快照的时候偶尔来个 -1，特蛋疼。花了很多时间排除问题。总结一点就是涉及的数量红线变更的必须用精确判断，不能范围判断。

6.技术难点：

一、概率的计算

二、库存变更

三、轮询策略

基本就上面三个点，我这里是灵活使用redis 做缓存共享（也可以使用db的悲观锁、乐观锁、版本号），使用了其中管道技术做时间维度上的奖品数据快照解决概率计算的正确性；事物技术解决库存变更；两者结合解决了轮询策略问题。做到了监控每个轮询前每一个奖品数量，精确到每个轮询每个用户所中的奖品和顺序。

二、代码干货

奖品类：

  1. public class Award {

  2. /**编号*/

  3. public String id;

  4. /**数量（该类奖品数量）*/

  5. public int count;

  6. /**价值（该类奖品价值积分）*/

  7. public int pointVal;

  8. /**剩余数量（该类奖品剩余数量）*/

  9. public int remainCount;

  10. public String getId() {

  11. return id;

  12. }

  13. public void setId(String id) {

  14. this.id = id;

  15. }

  16. public int getCount() {

  17. return count;

  18. }

  19. public void setCount(int count) {

  20. this.count = count;

  21. }

  22. public int getPointVal() {

  23. return pointVal;

  24. }

  25. public void setPointVal(int pointVal) {

  26. this.pointVal = pointVal;

  27. }

  28. public int getRemainCount() {

  29. return remainCount;

  30. }

  31. public void setRemainCount(int remainCount) {

  32. this.remainCount = remainCount;

  33. }

  34. /**

  35. *

  36. * @param id *编号*

  37. * @param count 数量（该类奖品数量）*

  38. * @param pointVal 价值（该类奖品价值积分）*

  39. * @param remainCount 剩余数量（该类奖品剩余数量）

  40. */

  41. public Award( String id, int count, int pointVal, int remainCount) {

  42. this.id = id;

  43. this.count = count;

  44. this.pointVal = pointVal;

  45. this.remainCount = remainCount;

  46. }

  47. @Override

  48. public String toString() {

  49. return "Award [id=" + id + ", count=" + count + ", pointVal="

  50. + pointVal + ", remainCount=" + remainCount + "]";

  51. }

  52. }

概率计算：

详细算法可以看看这篇文章。

  1. import java.util.ArrayList;

  2. import java.util.List;

  3. import java.util.Random;

  4. import java.util.Set;

  5. import redis.clients.jedis.Jedis;

  6. import redis.clients.jedis.Pipeline;

  7. /**

  8. *

  9. * @author XiongYC

  10. * @date 2017年12月3日

  11. *

  12. */

  13. public class LotteryUtil {

  14. public static String lottery(Jedis jedis) {

  15. try {

  16. /**

  17. * 读取redis 缓存参数（使用watch 确保数据准确性）

  18. */

  19. Set<String> set = jedis.smembers(TestDemo.PRIZE_LIST); //获取奖品列表（id）

  20. List<String> list = new ArrayList<String>(set.size()+1); //奖品列表（有序）

  21. //使用管道技术一次性获取所有奖品数量确保数据完整性和概率计算的正确性

  22. Pipeline p = jedis.pipelined();

  23. for (String id : set) {

  24. list.add(id); //增加奖品列表

  25. p.get(id);//获取换成奖品数量

  26. }

  27. list.add(TestDemo.RESIDUAL_QUANTITY);

  28. p.get(TestDemo.RESIDUAL_QUANTITY);

  29. List<Object> list1= p.syncAndReturnAll();//获取所有奖品的剩余数量

  30. int totailCount = Integer.valueOf(String.valueOf(list1.get(list1.size()-1))); //获取剩余奖品总数

  31. if (totailCount == 0) {

  32. // 重置奖品

  33. TestDemo.initData(jedis);

  34. return "-1";

  35. }

  36. // 存储每个奖品新的概率区间

  37. List<Float> proSection = new ArrayList<Float>();

  38. proSection.add(0f); //起始区间

  39. float totalPro = 0f; // 总的概率区间

  40. for (int i = 0; i < list1.size()-1; i++) {

  41. // awardCount += Float.valueOf(jedis.get(id)); //计算奖品现有总数量

  42. //弹性计算每个奖品的概率（剩余奖品数量/剩余总奖品数量） 每个概率区间为奖品概率乘以1000（把三位小数换为整）

  43. totalPro += (Float.valueOf(String.valueOf(list1.get(i))) / Float.valueOf(String.valueOf(list1.get(list1.size()-1)))) * 1000;

  44. proSection.add(totalPro);

  45. }

  46. // 获取总的概率区间中的随机数

  47. Random random = new Random();

  48. float randomPro = (float) random.nextInt((int) totalPro);

  49. for (int i = 0, size = proSection.size(); i < size; i++) {

  50. if (randomPro >= proSection.get(i) && randomPro < proSection.get(i + 1)) {

  51. return list.get(i);

  52. }

  53. }

  54. } catch (Exception e) {

  55. System.err.println("概率之外计算错误" + e.getMessage());

  56. return null;

  57. }

  58. return null;

  59. }

  60. }

库存共享变更:

  1. import java.util.List;

  2. import java.util.UUID;

  3. import redis.clients.jedis.Jedis;

  4. import redis.clients.jedis.Transaction;

  5. /**

  6. *

  7. * @author XiongYC

  8. * @date 2017年12月3日

  9. *

  10. */

  11. public class MyRunnable1 implements Runnable {

  12. private Jedis jedis = RedisPoolUtils.getJedis();

  13. @Override

  14. public void run() {

  15. try {

  16. // 查询剩余奖品总数

  17. String key = getPrize();

  18. System.err.println("线程" + Thread.currentThread().getName() + "中奖奖品id为：" + key);

  19. } catch (Exception e) {

  20. System.err.println("算法计算异常：异常原因 = " + e.getMessage());

  21. } finally {

  22. RedisPoolUtils.returnResourceObject(jedis);

  23. }

  24. }

  25. private String getPrize() {

  26. String key = LotteryUtil.lottery(jedis); //获取中奖奖品ID

  27. jedis.watch(key,TestDemo.RESIDUAL_QUANTITY); //精确监控单个奖品剩余数

  28. if("-1".equals(key) || "0".equals(jedis.get(key))){

  29. jedis.unwatch();

  30. key = getPrize();

  31. }else{

  32. // key = AvailablePrize(key);

  33. Transaction tx = jedis.multi(); //开启redis事物

  34. tx.incrBy(TestDemo.RESIDUAL_QUANTITY, -1); //减少总库存

  35. tx.incrBy(key, -1); //减少中奖奖品总库存

  36. List<Object> listObj = tx.exec(); //提交事务，如果此时watch key被改动了，则返回null

  37. if (listObj != null) { //多个进程同时 key>0 key相等时

  38. // String useId = UUID.randomUUID().toString();

  39. jedis.sadd("failuse", UUID.randomUUID().toString() + key);

  40. System.out.println("用户中奖成功！！！"); //中奖成功业务逻辑

  41. } else {

  42. key = getPrize(); //重新计算奖品

  43. }

  44. }

  45. return key;

  46. }

  47. //是否是有效奖品

  48. // private String AvailablePrize(String key) {

  49. // int prizeNum = Integer.valueOf(jedis.get(key));

  50. //

  51. // //奖品无效重新计算验证

  52. // if(prizeNum <= 0){

  53. // AvailablePrize(LotteryUtil.lottery(jedis));

  54. // }

  55. // return key;

  56. // }

  57. }

初始化：

  1. import java.util.ArrayList;

  2. import java.util.List;

  3. import java.util.Set;

  4. import java.util.concurrent.ExecutorService;

  5. import java.util.concurrent.Executors;

  6. import redis.clients.jedis.Jedis;

  7. import redis.clients.jedis.Pipeline;

  8. import redis.clients.jedis.Transaction;

  9. /**

  10. *

  11. * @author XiongYC

  12. * @date 2017年12月3日

  13. *

  14. */

  15. public class TestDemo {

  16. /**

  17. * 安慰奖

  18. */

  19. public static final String CONSOLATION_PRIZE_BY_ID= "2017112400005";

  20. /**

  21. * 缓存总次数 安慰奖+奖品

  22. */

  23. public static final String RESIDUAL_QUANTITY= "residualQuantity";

  24. /**

  25. * 奖品列表（ID）

  26. */

  27. public static final String PRIZE_LIST= "prizeList";

  28. /**

  29. * 每日抽奖所需积分

  30. */

  31. public static final String POINTS_REQUIRED_FOR_THE_LOTTERY = "pointsRequiredForTheLlottery";

  32. /**

  33. * 轮询成功次数

  34. */

  35. public static final String POLLING_SUCCESS_NUM = "POLLING_SUCCESS_NUM";

  36. /**

  37. * 轮询失败次数

  38. */

  39. public static final String POLLING_FAIL_NUM = "POLLING_FAIL_NUM";

  40. /**

  41. * 轮询奖品数量快照

  42. */

  43. public static final String SNAPSHOT_LIST = "SNAPSHOT_LIST";

  44. /**

  45. *中奖用户记录

  46. */

  47. public static final String FAILUSE = "FAILUSE";

  48. /**

  49. * 从redis连接池获取连接

  50. */

  51. private static Jedis jedis = RedisPoolUtils.getJedis();

  52. public static void main(String[] args) {

  53. try {

  54. // jedis.del(POLLING_SUCCESS_NUM,POLLING_FAIL_NUM,SNAPSHOT_LIST,FAILUSE);

  55. // jedis.set(RESIDUAL_QUANTITY, "0");

  56. jedis.flushAll();//清除数据库

  57. // 初始化奖品参数

  58. initData(jedis);

  59. ExecutorService executor = Executors.newFixedThreadPool(50);

  60. for (int i = 0; i <2400; i++) {

  61. executor.execute(new MyRunnable1());

  62. }

  63. executor.shutdown();

  64. } catch (Exception e) {

  65. System.err.println("ERROR_MSG = " + e.getMessage());

  66. }finally{

  67. if(jedis!=null){

  68. RedisPoolUtils.returnResourceObject(jedis);//释放redis资源

  69. }

  70. }

  71. }

  72. /**

  73. * 初始化奖品参数

  74. */

  75. public static void initData(Jedis jedis) {

  76. Award award1 = new Award("2017112400001", 1, 2000, 1); //一等奖

  77. Award award2 = new Award("2017112400002", 2, 1500, 2); //二等奖

  78. Award award3 = new Award("2017112400003", 3, 1000, 3); //三等奖

  79. Award award4 = new Award("2017112400004", 4, 500, 4); //四等奖

  80. List<Award> list = new ArrayList<Award>();

  81. list.add(award1);

  82. list.add(award2);

  83. list.add(award3);

  84. list.add(award4);

  85. int tailCount = 0; //总奖品数

  86. int tailPoint = 0; //总奖品总积分值

  87. /**

  88. * 读取redis 缓存参数（使用watch 确保数据准确性）

  89. */

  90. Set<String> set = jedis.smembers(TestDemo.PRIZE_LIST); //获取奖品列表（id）

  91. //轮询快照

  92. Pipeline p = jedis.pipelined();

  93. for (String id : set) {

  94. p.get(id);//获取换成奖品数量

  95. }

  96. p.get(RESIDUAL_QUANTITY);

  97. List<Object> temp = p.syncAndReturnAll();//获取所有奖品的剩余数量

  98. //开始初始化缓存奖品数据

  99. for (int i = 0; i < list.size(); i++) {

  100. jedis.sadd(PRIZE_LIST, list.get(i).id); //缓存奖品列表

  101. jedis.set(list.get(i).id, String.valueOf(list.get(i).count));//缓存奖品数量

  102. tailCount +=list.get(i).count; //计算总奖品数

  103. tailPoint += list.get(i).count* list.get(i).pointVal; //计算奖品总积分值

  104. }

  105. jedis.set(POINTS_REQUIRED_FOR_THE_LOTTERY, "500"); //每次抽奖所需积分

  106. int residualQuantity = tailPoint / Integer.valueOf(jedis.get(POINTS_REQUIRED_FOR_THE_LOTTERY)); //计算未中奖次数（安慰奖）

  107. int missesNum = residualQuantity - tailCount; //安慰剂次数

  108. jedis.watch(RESIDUAL_QUANTITY);

  109. int count = 0;

  110. //判断是否是初次轮询

  111. if(jedis.exists(RESIDUAL_QUANTITY)){

  112. count= Integer.valueOf(jedis.get(RESIDUAL_QUANTITY));

  113. }

  114. if(count == 0){

  115. Transaction tx = jedis.multi();

  116. tx.set(CONSOLATION_PRIZE_BY_ID, String.valueOf(missesNum)); //缓存安慰奖次数

  117. tx.sadd(PRIZE_LIST, CONSOLATION_PRIZE_BY_ID); //缓存安慰奖到奖品列表

  118. tx.set(RESIDUAL_QUANTITY, String.valueOf(residualQuantity)); // 缓存总次数 安慰奖+奖品

  119. List<Object> obj = tx.exec();

  120. if (obj != null) { // 多个进程同时 key>0 key相等时

  121. jedis.incrBy(POLLING_SUCCESS_NUM,1);

  122. jedis.sadd(SNAPSHOT_LIST, jedis.get(POLLING_SUCCESS_NUM)+temp.toString());

  123. System.out.println("初始化成功=============================》！！！");

  124. } else {

  125. jedis.incrBy(POLLING_FAIL_NUM,1);

  126. System.err.println("初始化失败=============================》！！！");

  127. }

  128. }else{

  129. jedis.unwatch();

  130. }

  131. }

  132. }

三、数据验证

案例：根据以上demo我们可以看出有五个奖品（四个真正的奖品，一个安慰奖），我们根据设置的四个奖品可以得出 总积分价值为10000积分，每次抽奖500积分，一共需要抽20次完成一轮轮询，其中真正的奖品为10个，其余的10为安慰奖个数。

论证：现在我们用50个线程跑2400个请求

预期效果：我们会有2400/20=120次轮询，每次轮询奖品剩余库存数据快照为 轮询次数+[0,0,0,0,0]，每次轮询抽奖结果为一等奖1个，二等奖2个，三等奖3个。四等奖4个，五等奖10个(安慰奖)，共20个奖品；

实际效果：

轮询次数120次。，--验证通过

每次轮询奖品剩余库存数据快照

我截取了最好一部分数据快照，可以看出数据条数是可以对上轮询次数的，快照数据也是没问题的。--验证通过

每次轮询抽奖结果 ：我随机抽取了一个循环的奖品记录

  1. 初始化成功=============================》！！！

  2. 线程pool-1-thread-46中奖奖品id为：2017112400005

  3. 用户中奖成功！！！

  4. 用户中奖成功！！！

  5. 线程pool-1-thread-14中奖奖品id为：2017112400003

  6. 线程pool-1-thread-43中奖奖品id为：2017112400005

  7. 用户中奖成功！！！

  8. 线程pool-1-thread-30中奖奖品id为：2017112400005用户中奖成功！！！

  9. 线程pool-1-thread-36中奖奖品id为：2017112400001

  10. 用户中奖成功！！！

  11. 线程pool-1-thread-13中奖奖品id为：2017112400002

  12. 用户中奖成功！！！

  13. 线程pool-1-thread-49中奖奖品id为：2017112400005

  14. 用户中奖成功！！！

  15. 线程pool-1-thread-5中奖奖品id为：2017112400005

  16. 用户中奖成功！！！

  17. 线程pool-1-thread-25中奖奖品id为：2017112400005

  18. 用户中奖成功！！！

  19. 线程pool-1-thread-35中奖奖品id为：2017112400003

  20. 用户中奖成功！！！

  21. 线程pool-1-thread-18中奖奖品id为：2017112400003

  22. 用户中奖成功！！！

  23. 用户中奖成功！！！

  24. 线程pool-1-thread-25中奖奖品id为：2017112400004

  25. 用户中奖成功！！！

  26. 线程pool-1-thread-38中奖奖品id为：2017112400005

  27. 用户中奖成功！！！

  28. 线程pool-1-thread-15中奖奖品id为：2017112400004

  29. 用户中奖成功！！！

  30. 线程pool-1-thread-48中奖奖品id为：2017112400004

  31. 用户中奖成功！！！

  32. 线程pool-1-thread-7中奖奖品id为：2017112400005

  33. 用户中奖成功！！！

  34. 线程pool-1-thread-37中奖奖品id为：2017112400002

  35. 用户中奖成功！！！

  36. 线程pool-1-thread-12中奖奖品id为：2017112400004

  37. 线程pool-1-thread-31中奖奖品id为：2017112400005

  38. 用户中奖成功！！！

  39. 用户中奖成功！！！

  40. 线程pool-1-thread-1中奖奖品id为：2017112400005

后台成功中奖记录里面条数也对应上了2400请求（有的细心的小伙伴可能会直接去缓存里面按行数来去验证奖品数量，我这里用的是集合，小伙伴们可以自行缓存list存储验证）。--验证通过。

以上就是全部内容了，有点糙，还望见谅。

转载于:https://my.oschina.net/demons99/blog/2231163

redis高并发抽奖相关推荐

  1. redis高并发原理_Java中的42行代码中的URL缩短服务— Java（？！）Spring Boot + Redis...

    redis高并发原理 显然,编写URL缩短服务是新的"世界,您好! "在物联网/微服务/时代的世界中. 一切始于在45行Scala中的URL缩短服务-整洁的Scala,以Spray ...

  2. java连接redis不稳定_java相关：jedispool连redis高并发卡死的问题

    java相关:jedispool连redis高并发卡死的问题 发布于 2020-6-30| 复制链接 本篇文章主要介绍了jedispool连redis高并发卡死的问题,小妖觉得挺不错的,现在分享给大家 ...

  3. Redis高并发点赞

    1.redis高并发点赞就是保护数据库进行的操作 原理:就是将点赞数和点赞用户先存入redis中(防止大量用户数据对数据库的操作),通过定时任务在将数据取出来. 操作: 1.先将前端的数据存入redi ...

  4. 解决redis高并发问题的几种思路

    解决redis高并发问题的几种思路 1:布隆过滤器 首先,布隆过滤器能解决绝大部分恶意攻击的请求,比如我们数据库中的id通常都设为自增的,是有一定范围大小的,如果有黑客恶意用数据库中没有的id一直访问 ...

  5. 高并发专题--5：关于redis高并发你晓得多少?

    关于redis高并发你晓得多少? 1.redis高并发跟整个系统的高并发之间的关系 2.redis不能支撑高并发的瓶颈在哪里? 3.如果redis要支撑超过10万+的并发,那应该怎么做? 4.redi ...

  6. Redisson分布式锁实战（适用于Redis高并发场景）

    实现方式一:存在抛异常后lock值无法归0的问题 @Autowired private StringRedisTemplate stringRedisTemplate;@RequestMapping( ...

  7. java redis使用卡死_jedispool连redis高并发卡死的问题

    java端在使用jedispool 连接redis的时候,在高并发的时候经常死锁,或报连接异常,JedisConnectionException,或者getResource 异常等各种问题 在使用je ...

  8. redis高并发数据错乱_redis总结：1T以上海量数据+10万以上QPS高并发+99.99%高可用...

    来源:https://blog.csdn.net/qq_34246646/article/details/104402510 redis作用 topic:高并发.亿级流量.高性能.海量数据的场景,电商 ...

  9. php redis auth 高并发,PHP+Redis高并发

    初学Redis,于是便想写一个高并发的项目,最开始只能达到并发量1,后来增加并发,出现各种问题,我又采取各种办法来增大并发量,在慢慢增大并发量的过程中,我也在慢慢成长,在追求成功的过程中,越来越兴奋, ...

最新文章

  1. JS设计模式（13）状态模式
  2. 云计算里的安全：警惕云服务被恶意利用
  3. silverlight中递归构造无限级树treeview+checkbox
  4. 八十四、搜索框动画效果实现，React-Redux 进行应用数据的管理
  5. CodeIgniter模型
  6. DVWA--File Inclusion(文件包含)--四个级别
  7. mysql下一个版本号_mysql下一个版本应该且实现并不复杂增加的常用功能
  8. adf开发_ADF：动态视图对象
  9. 知识点old1908
  10. 程序员是吃青春饭的，为啥还有这么多人想转行当程序员？
  11. mysql父子节点分层_mysql 递归实例 父子节点层级递归
  12. Action类一般情况为何要继承ActionSupport
  13. Telnet 工具远程连接服务器
  14. mame0.239选定系统所需要的ROM/磁碟映像档为缺少或不正确
  15. BZOJ 2006超级钢琴
  16. 阿里ESC7天训练营---搭建FTP服务
  17. jQuery - 设置div的内容和属性
  18. Oracle XE版安装与用户操作
  19. nginx: [warn] conflicting server name “www.yqq.org“ on 0.0.0.0:80, ignored
  20. DB2 错误解决方案：A system temporary table space with sufficient page size does not exist.. SQLCODE=-1585,

热门文章

  1. Vue.js 深入响应式原理
  2. 面向组合子程序设计方法 之 新约
  3. 深入理解JVM(1)——Java内存区域与Java对象
  4. iOS中MVC设计模式
  5. 最简实例说明wait、notify、notifyAll的使用方法
  6. Office word中mathtype公式与LaTex公式代码互转
  7. 日文 LaTeX 系统介绍 - 最简示例
  8. MySQL数据库Keepalived双主
  9. 关于Mysql5.7高版本group by新特性报错
  10. 防火墙如可禁止tracert但允许ping