【实践】练习抢红包逻辑

最新推荐文章于 2024-05-24 02:08:26 发布
最新推荐文章于 2024-05-24 02:08:26 发布
阅读量86 收藏
点赞数
文章标签： java 抢红包
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sheldon74/article/details/131242054
版权 
以下实现仅个人练习，仅供参考，不足之处请多多留言指教，感激不尽。

分析

抢红包有以下信息需要考虑：

  • 红包总额：一般固定
  • 红包数量：固定或不定
  • 抢红包人数：不定
  • 每个红包大小：固定或随机
    • 抢红包策略：公平或随机

公平抢红包

基本逻辑实现：

public class GradCommon {
    private int redPacket;
    private int redPacketNumber;
    private final int redPacketSize;
    private final int lastRedPacketSize;

    public GradCommon(int redPacket,int redPacketNumber) {
        this.redPacketNumber = redPacketNumber;
        this.redPacketSize = redPacket/redPacketNumber;
        this.lastRedPacketSize = redPacketSize + redPacket % redPacketNumber;
    }

    public int grad(){
        int currentRedPacket = 0;
        if (redPacketNumber>0){
            redPacketNumber--;
            currentRedPacket = redPacketSize;
            if (redPacketNumber == 1){
                currentRedPacket = lastRedPacketSize;
            }
            System.out.println(Thread.currentThread().getName() + " 抢到红包" + currentRedPacket + "分，奖励一下！");
        }else {
            System.out.println(Thread.currentThread().getName() + " 未抢到，感觉错过了一个亿！");
        }
        return currentRedPacket;
    }
}

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入红包总金额(分)：");
        int redPacket = scanner.nextInt();
        System.out.println("请输入红包总数：");
        int redPacketNumber = scanner.nextInt();
        System.out.println("请输入抢红包人数");
        int people = scanner.nextInt();

        GradCommon grad = new GradCommon(redPacket,redPacketNumber);
        for (int i = 0; i < people; i++) {
            grad.grad(); // 注意此位置问题
        }
    }

以上代码逻辑问题：

  • 不能实现同时开抢，只能排队抢

改进1.0

每个人抢红包的动作作为一个独立的线程，所以以多个线程方式抢红包，并且使用CountDownLatch实现同时开抢效果：

public class GradThread implements Runnable{
    private int redPacketNumber;
    private final int redPacketSize;
    private final int lastRedPacketSize;

    private final CountDownLatch countDownLatch;

    public GradThread(int redPacket, int redPacketNumber,CountDownLatch countDownLatch) {
        this.redPacketNumber = redPacketNumber;
        this.countDownLatch = countDownLatch;
        this.redPacketSize = redPacket / redPacketNumber;
        this.lastRedPacketSize = this.redPacketSize + redPacket % redPacketNumber;
    }

    @Override
    public void run() {
        try {
            countDownLatch.await(); // 争取同时开始竞价
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        if (redPacketNumber>0){
            redPacketNumber--;
            int currentRedPacket = redPacketSize;
            if (redPacketNumber == 1){
                currentRedPacket = lastRedPacketSize;
            }
            System.out.println(Thread.currentThread().getName() + " 抢到红包" + currentRedPacket + "分，奖励一下！");
        }else {
            System.out.println(Thread.currentThread().getName() + " 未抢到，感觉错过了一个亿！");
        }
    }
}

    public static void main(String[] args) {
        // ...同上
        CountDownLatch countDownLatch = new CountDownLatch(1);
        GradThread gradThread = new GradThread(redPacket,redPacketNumber,countDownLatch);
        for (int i = 0; i < people; i++) {
           new Thread(gradThread).start();
        }
        countDownLatch.countDown();// 将值降为0，代表同时启动countDownLatch.await()的后续逻辑
    }

问题：

  • 无法保证数据安全，容易造成红包超出计划。

改进2.0

增加同步锁synchronized实现抢红包代码块锁定，避免红包超出

public class GradThread implements Runnable{
    // ...其他同上
    // 增加一个对象锁
    private final Object lock = new Object();

    @Override
    public void run() {
        try {
            countDownLatch.await(); 
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        synchronized (lock){ // 加锁避免超出
            if (redPacketNumber>0){
                redPacketNumber--;
                int currentRedPacket = redPacketSize;
                if (redPacketNumber == 1){
                    currentRedPacket = lastRedPacketSize;
                }
                System.out.println(Thread.currentThread().getName() + " 抢到红包" + currentRedPacket + "分，奖励一下！");
            }else {
                System.out.println(Thread.currentThread().getName() + " 未抢到，感觉错过了一个亿！");
            }
        }
    }
}

随机红包

随机红包即每个人抢到的红包并不是固定的，是随机下发的。

public class RandomGradThread  implements Runnable
    private final Random random = new Random();
    private int redPacketNumber; // 红包数量
    private int redPacket; // 红包总额
    private int gradRedPacketNumber; // 已抢红包数量
    private int gradRedPacket;// 已抢红包总额
    private final int minRedPacket = 1; // 在红包数量有效的情况下，每个红包最少有一个，不能为0
    private final CountDownLatch countDownLatch;

    public RandomGradRedPacket(int redPacket,int redPacketNumber,CountDownLatch countDownLatch) {
        this.redPacket = redPacket;
        this.redPacketNumber = redPacketNumber;
        this.countDownLatch = countDownLatch;
        System.out.println("。。。随机红包逻辑。。。");
    }
    @Override
    public void run() {
        try {
            countDownLatch.await(); // 争取同时开始竞价
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        grad();
    }

    // 抢红包逻辑
    private synchronized void grad() {
        if (redPacketNumber == 0){
            System.out.println(Thread.currentThread().getName() + " 未抢到，感觉错过了一个亿！");
            return;
        }
        int currentRedPacket = gradCurRedPacket();
//        assert currentRedPacket > 0:"红包大小不应该为0！";
        if (currentRedPacket == 0){
            throw new RuntimeException("红包大小不应该为0！");
        }
        redPacketNumber--;
        System.out.println(Thread.currentThread().getName() + " 抢到红包" + currentRedPacket + "分，奖励一下！");
        grad(currentRedPacket);
    }
    // 记录已抢红包情况
    private void grad(int gradRedPacket){
        gradRedPacketNumber++;
        this.gradRedPacket += gradRedPacket;
        System.out.println("已抢红包"+gradRedPacketNumber + "个，已抢红包" + gradRedPacket + "分，剩余红包" + (redPacket - this.gradRedPacket) + "分。");
    }
    // 计算应抢红包额度
    private int gradCurRedPacket() {
        int residue = this.redPacket - this.gradRedPacket;
        if (redPacketNumber == 1) return residue;
        int currentRedPacket = 0;
        while (currentRedPacket == 0){
            currentRedPacket = random.nextInt(residue - (redPacketNumber - 1) * minRedPacket);
        }
        return currentRedPacket;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入红包总金额(分)：");
        int redPacket = scanner.nextInt();
        System.out.println("请输入红包总数：");
        int redPacketNumber = scanner.nextInt();
        System.out.println("请输入抢红包人数");
        int people = scanner.nextInt();
        
        CountDownLatch countDownLatch = new CountDownLatch(1);
        RandomGradThread grad = new RandomGradThread(redPacket,redPacketNumber,countDownLatch);
        for (int i = 0; i < people; i++) {
            new Thread(grad).start; // 注意此位置问题
        }
        countDownLatch.countDown();
    }

整合版

即抽出统一的抢红包逻辑，根据不同逻辑定义不同实现：


public class RedPacketThread implements Runnable{

    private final CountDownLatch countDownLatch;
    private final AbstractGradRedPacket redPacket;

    public RedPacketThread(CountDownLatch countDownLatch, AbstractGradRedPacket redPacket) {
        this.countDownLatch = countDownLatch;
        this.redPacket = redPacket;
    }

    @Override
    public void run() {
        try {
            countDownLatch.await(); // 争取同时开始竞价
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        redPacket.grad();
    }
}
/**
 * 抢红包抽象类
 */
public abstract class AbstractGradRedPacket {
    protected int redPacket;
    protected int gradRedPacketNumber;
    protected int gradRedPacket;

    public AbstractGradRedPacket(int redPacket) {
        this.redPacket = redPacket;
    }

    abstract void grad();

    // 收集已抢红包情况
    public synchronized void grad(int gradRedPacket){
        gradRedPacketNumber++;
        this.gradRedPacket += gradRedPacket;
        System.out.println("已抢红包"+gradRedPacketNumber + "个，已抢红包" + gradRedPacket + "分，剩余红包" + (redPacket - this.gradRedPacket) + "分。");
    }
}

/**
 * 固定红包总额和数量的抢红包抽象逻辑
 */
public abstract class FixRedPacket extends AbstractGradRedPacket{

    protected int redPacketNumber;

    public FixRedPacket(int redPacket,int redPacketNumber) {
        super(redPacket);
        this.redPacketNumber = redPacketNumber;
    }

    @Override
    synchronized void grad() {
        if (redPacketNumber == 0){
            System.out.println(Thread.currentThread().getName() + " 未抢到，感觉错过了一个亿！");
            return;
        }
        int currentRedPacket = gradCurRedPacket();
//        assert currentRedPacket > 0:"红包大小不应该为0！";
        if (currentRedPacket == 0){
            throw new RuntimeException("红包大小不应该为0！");
        }
        redPacketNumber--;
        System.out.println(Thread.currentThread().getName() + " 抢到红包" + currentRedPacket + "分，奖励一下！");
        grad(currentRedPacket);
    }

    abstract int gradCurRedPacket();
}

/**
 * 固定红包
 */
public class FailGradRedPacket extends FixRedPacket{

    private final int redPacketSize;
    private final int lastRedPacketSize;

    public FailGradRedPacket(int redPacket, int redPacketNumber) {
        super(redPacket,redPacketNumber);
        this.redPacketSize = redPacket / redPacketNumber;
        this.lastRedPacketSize = this.redPacketSize + redPacket % redPacketNumber;
        System.out.println("。。。公平红包逻辑。。。");
    }

    @Override
    int gradCurRedPacket() {
        int currentRedPacket = redPacketSize;
        if (redPacketNumber == 1){
            currentRedPacket = lastRedPacketSize;
        }
        return currentRedPacket;
    }
}

/**
 * 随机红包
 */
public class RandomGradRedPacket extends FixRedPacket{

    private final Random random = new Random();
    private final int minRedPacket = 1;

    public RandomGradRedPacket(int redPacket,int redPacketNumber) {
        super(redPacket,redPacketNumber);
        System.out.println("。。。随机红包逻辑。。。");
    }

    @Override
    synchronized int gradCurRedPacket() {
        int residue = this.redPacket - this.gradRedPacket;
        if (redPacketNumber == 1) return residue;
        int currentRedPacket = 0;
        while (currentRedPacket == 0){
            currentRedPacket = random.nextInt(residue - (redPacketNumber - 1) * minRedPacket);
        }
        return currentRedPacket;
    }

    private int gradRedPacket(int residue){
        int currentRedPacket = 0;
        while (currentRedPacket == 0){
            currentRedPacket = random.nextInt(residue - (redPacketNumber - 1) * minRedPacket);
        }
        return currentRedPacket;
    }
}

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入红包总金额(分)：");
        int redPacket = scanner.nextInt();
        System.out.println("请输入红包总数：");
        int redPacketNumber = scanner.nextInt();
        System.out.println("请输入抢红包人数");
        int people = scanner.nextInt();
        CountDownLatch countDownLatch = new CountDownLatch(1);
        AbstractGradRedPacket gradRedPacket;
//        gradRedPacket = new FailGradRedPacket(redPacket,redPacketNumber);
        gradRedPacket = new RandomGradRedPacket(redPacket,redPacketNumber);
        RedPacketThread redPacketThread = new RedPacketThread(countDownLatch,gradRedPacket);
        for (int i = 0; i < people; i++) {
            new Thread(redPacketThread).start();
        }
        countDownLatch.countDown();
    }

测试

请输入红包总金额(分)：
100
请输入红包总数：
10
请输入抢红包人数
12
。。。随机红包逻辑。。。
Thread-3 抢到红包38分，奖励一下！
已抢红包1个，已抢红包38分，剩余红包62分。
Thread-7 抢到红包42分，奖励一下！
已抢红包2个，已抢红包42分，剩余红包20分。
Thread-4 抢到红包7分，奖励一下！
已抢红包3个，已抢红包7分，剩余红包13分。
Thread-5 抢到红包1分，奖励一下！
已抢红包4个，已抢红包1分，剩余红包12分。
Thread-8 抢到红包1分，奖励一下！
已抢红包5个，已抢红包1分，剩余红包11分。
Thread-6 抢到红包6分，奖励一下！
已抢红包6个，已抢红包6分，剩余红包5分。
Thread-2 抢到红包1分，奖励一下！
已抢红包7个，已抢红包1分，剩余红包4分。
Thread-9 抢到红包1分，奖励一下！
已抢红包8个，已抢红包1分，剩余红包3分。
Thread-1 抢到红包1分，奖励一下！
已抢红包9个，已抢红包1分，剩余红包2分。
Thread-10 抢到红包2分，奖励一下！
已抢红包10个，已抢红包2分，剩余红包0分。
Thread-11 未抢到，感觉错过了一个亿！
Thread-0 未抢到，感觉错过了一个亿！
Dongle74
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
L2-009 抢红包 (25分)
qq_45798109的博客
02-10 1793
没有人没抢过红包吧…… 这里给出N个人之间互相发红包、抢红包的记录，请你统计一下他们抢红包的收获。 输入格式： 输入第一行给出一个正整数N（≤10​4​​ ），即参与发红包和抢红包的总人数，则这些人从1到N编号。随后N行，第i行给出编号为i的人发红包的记录，格式如下： KN​1​​ P​1​​ ⋯N​K​​ P​K​​ 其中K（0≤K≤20）是发出去的红包个数，N​i​​ 是抢到红包的人的编号，P...
WIN32多线程抢红包练习
hambaga的博客
06-02 453
第一个文本框是奖池，右面三个文本框是三个线程抢到的红包数，程序运行结果如下： 解决资源抢占问题，WIN32提供两种方式：临界区和互斥体。 临界区和互斥体的对比： 1、临界区只能应用于单个进程间的线程控制，互斥体可以跨进程； 2、互斥体可以设定阻塞等待超时，临界区不能； 3、线程意外终结时，互斥体可以避免死锁； 4、互斥体效率比临界区低。 临界区实现 // RedPack.cpp : Defines the entry point for the application. // #include "st
多线程练习4 (抢红包)
qq_51565600的博客
04-01 420
多线程应用到抢红包上
Java小练习（抢红包）
Croyants的博客
12-08 366
需求： 一个大V直播抽奖，奖品是现金红包，分别有{2,588,888,1000,10000}五个奖金。 请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。
java代码实现模拟抢红包算法逻辑
野的博客
04-26 1387
保证两个条件 每份红包最低金额为1分 总份数加起来等于总金额 public class MoneyTest { public static void main(String[] args) { double money = 10; int num = 6; System.out.println("总金额："+ money +"元\t ...
简书android微信抢红包,GO从0到1实战微服务版抢红包系统
weixin_39911475的博客
05-29 287
GO从0到1实战微服务版抢红包系统想必大家对“双十一”、“6.18”秒杀活动有高并发性能的直观感受， “抢红包” 在高并发上比“秒杀”更经典 ，与Golang更契合。致敬经典，开启从0到1实战抢红包系统学习之旅：从基础逻辑设计到编程实操，到性能分析找到瓶颈，按架构演进迭代系统。想在企业中彰显能力，等你来打Cal第1章 课程导学【征途*扬帆起航】没有梦想，何必远方?本小结将站在更高的起点，从项目演示...
简单的python抢红包脚本-python+红包
weixin_37988176的博客
10-30 2583
广告关闭2017年12月，云+社区对外发布，从最开始的技术博客到现在拥有多个社区产品。未来，我们一起乘风破浪，创造无限可能。为了除夕夜不错过几个亿的红包，特意下载了一个红包助手，用来提醒自己微信好友发红包的信息，就这样还是败在了手速上。 在使用红包助手的时候发现一个缺点：屏蔽的群，发红包时不提醒。 作为爱折腾的我，今天就针对红包助手进行了优化，写了一个python脚本助你抢红包，完美了解决了屏蔽的...
C语言实现抢红包程序代码精简版
01-20
本文实例为大家分享了Android九宫格图片展示的具体代码，供大家参考，具体内容如下 其实这是段相当简单的代码，至于为什么还要把它放在...下面将给大家一个精简版的抢红包的程序，自己拿着去运行一下吧。 #include #
JAVA随机数随机字母（微信抢红包小练习）
01-20
今天我们谈一谈JAVA中的随机数 你好WO SHI 七七卡卡 ^ _ ^ 随机数 ——Math.random() 0.0 在Math类中存在一个random()方法，用于产生随机数字，这个方法生成在0.0<=生成数<1.0 0.1那么它默认的生成的数显然在...
visio 图表 实践练习2
04-19
作业
练习：添加逻辑卷1
08-03
1.创建物理资源 2.创建物理卷 3.创建卷组 4.创建逻辑卷 5.添加永久件系统 6.测试并检查作
数字逻辑电路ppt及练习题
07-13
数字逻辑电路ppt及练习题，部分有重复。
android高斯模糊填充imageview背景
cf8833的博客
05-21 355
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
SpringBoot接入Knife4j接口文档
博主是个二次元死肥宅~
05-18 780
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 429
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
java学习和项目总结
最新发布
2301_79390585的博客
05-24 268
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
SpringBoot Validation自定义注解之校验指定最小整数
thinkers
05-21 105
1，引入核心关键依赖。
JVM学习-执行引擎
丢爸
05-21 810
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。
java逻辑运算符练习题
10-24
以下是几个Java逻辑运算符的练习题： 1. 编写一个程序，判断一个整数是否为奇数并且大于10。 2. 编写一个程序，判断一个字符串是否为空或者长度小于等于5。 3. 编写一个程序，判断一个年份是否为闰年并且大于2000。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值