java多线程实现抢红包（介绍四种红包分配算法实现方式）

最新推荐文章于 2024-07-16 08:13:40 发布
置顶 最新推荐文章于 2024-07-16 08:13:40 发布
阅读量4.9k 收藏 50
点赞数 10
分类专栏： 多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imaniy/article/details/87803488
版权

实现要点

  1. 熟悉java多线程应用
  2. 对抢红包逻辑有所了解。
    主要分成三个部分：
    1.红包（红包的总金额、每个红包金额、红包数量、是否预先分配）
    2.人（每一个线程当做一个人）
    3.抢红包（多个人抢红包，返回抢到的金额或者提示没有抢到）

第一种：抢红包时随机生成红包（规定总金额和数量）

红包： 在抢红包的过程中剩余金额会不断减少，要保证不能两个人同时抢，需要加上悲观锁，同一时间只可以一个人抢，加synchronized锁

/**
 * @author liuzonghua
 * @Package thread
 * @Description: 红包算法：抢时分配金额，金额波动为0-平均值*2
 *服务器压力较大
 * @date 2019/2/8 21:30
 */
public class HongBao {
    private double total;// 总钱数
    private int totalVal; // 总钱数小数化整数
    private int count; //红包总数

    public HongBao(double total, int count) {
        this.totalVal = (int)(total *100);//把总钱数化为整数
        this.count = count;
    }

    public synchronized double getRandomMoney(){
        int val;//每个人分配到的金额*100
        //当剩下的每一个人只分到一分钱的时候
        if(count !=0 && totalVal/count ==1){
            val = 1;
            totalVal = totalVal -val;
            count--;
            return val/100.0;
        }

        if(count <= 0){
            val = 0;
        }else if(count == 1){
            val =totalVal;//如果是最后一个
        }else {
            int temp; //剩下的金额
            while(true) {
                // 随机生成当前金额的随机数 [0,totalVal/count-1),尽量平均一点
                val = new Random().nextInt(totalVal/count*2);
                temp = totalVal - val;
                // 判断生成的金额大于0，且剩余的钱数够剩下人平分到0.01元

                if(temp*1.0/(count-1) >= 1 && val > 0) {
                    //System.out.println("生成金额 ：" + val + "剩余金额 ：" + temp + "剩余人数 ：" + (count-1));
                    break;
                }
            }
            totalVal = totalVal - val;
        }
        count--;
        return val/100.0;
    }
}

人： 人在这里用线程代替

public class UserThread implements Runnable{
    private HongBao hongBao;

    public UserThread(HongBao hongBao) {
        this.hongBao = hongBao;
    }

    @Override
    public void run() {
        double money = hongBao.getRandomMoney();
        if(money == 0) {
            System.out.println(Thread.currentThread().getName() + "不好意思，您手慢了！");
        }else {
            System.out.println(Thread.currentThread().getName() + "抢到 " + money + "元");
        }

    }
}

抢红包： 启动多个线程抢红包

public class QiangHongBao {
    public static void main(String[] args) {
        HongBao hongBao =new HongBao(8.1,8);
        UserThread user = new UserThread(hongBao);
        for(int i=0;i<10;i++) {
            new Thread(user).start();
        }
}
}

第二种：提前分配好金额（规定总金额和数量）

红包： 提前分配好金额，金额存在一个集合（队列）抢红包时根据顺序取金额，需要加上悲观锁，同一时间只可以一个人抢，加synchronized锁

public class HongBao2 {
    private double total;// 总钱数
    private int totalVal; // 总钱数小数化整数
    private int count; //红包总数
    private List<Double> valList;//红包分配集合

    public HongBao2(double total, int count) {
        this.totalVal = (int)(total *100);//把总钱数化为整数
        this.count = count;
        this.valList = new ArrayList<Double>();
        for(int i=0;i<count;i++) {
            int val;//每个人分配到的金额*100
            //当剩下的每一个人只分到一分钱的时候
            if(count !=0 && totalVal/count ==1){
                val = 1;
                totalVal = totalVal -val;

                valList.add(val/100.0);
            }

            if(count <= 0){
                val = 0;
            }else if(count == 1){
                val =totalVal;//如果是最后一个
            }else {
                int temp; //剩下的金额
                while(true) {
                    // 随机生成当前金额的随机数 [0,totalVal/count*2) 金额波动为0-平均值*2
                    val = new Random().nextInt(totalVal/count*2);
                    temp = totalVal - val;
                    // 判断生成的金额大于0，且剩余的钱数够剩下人平分到0.01元

                    if(temp*1.0/(count-1) >= 1 && val > 0) {
                        //System.out.println("生成金额 ：" + val + "剩余金额 ：" + temp + "剩余人数 ：" + (count-1));
                        break;
                    }
                }
                totalVal = totalVal - val;
            }
            valList.add(val/100.0);
        }
    }

    public synchronized double getRandomMoney(){
        double money = 0;
        if(count > 0){
            money =valList.get(count-1)/1.0;
        }
        count--;
        return money;
    }
}

人： 人在这里用线程代替

public class UserThread2 implements Runnable{
    private HongBao2 hongBao2;

    public UserThread2(HongBao2 hongBao2) {
        this.hongBao2 = hongBao2;
    }

    @Override
    public void run() {
        double money = hongBao2.getRandomMoney();
        if(money == 0) {
            System.out.println(Thread.currentThread().getName() + "不好意思，您手慢了！");
        }else {
            System.out.println(Thread.currentThread().getName() + "抢到 " + money + "元");
        }

    }
}

抢红包： 启动多个线程抢红包

public class QiangHongBao {
    public static void main(String[] args) {

        HongBao2 hongBao2 =new HongBao2(8.1,8);

        UserThread2 user2 = new UserThread2(hongBao2);
        for(int i=0;i<10;i++) {
            new Thread(user2).start();
        }
    }
}

第三种：知道总金额，不确定红包数,总金额发完即止

为实现其效果：

  • 方案一：伪代码实现，算法对于用户是黑盒的。可以套用前面两种方法，规定总金额和红包数，以红包数发完即止代替总金额发完即止。
    虽然实现过程不同，但实现效果完全一样。
  • 方案二：真代码实现，每一个线程获取一红包，但总金额小于某个值（平均值或者平均值*2）后面线程返回没抢到提示。

红包： 在抢红包的过程中剩余金额会不断减少，要保证不能两个人同时抢，需要加上悲观锁，同一时间只可以一个人抢，加synchronized锁

public class HongBao3 {
    private double total;// 总钱数
    private int totalVal; // 总钱数小数化整数
    private int ceilVal;//红包最高额度*100 取整


    public HongBao3(double total,int ceilVal) {
        this.totalVal = (int)(total *100);//把总钱数化为整数
        this.ceilVal = ceilVal*100;
    }

    public synchronized double getRandomMoney(){
        int val;//每个人分配到的金额*100
        // 随机生成当前金额的随机数 [0,ceilVal)
        val = new Random().nextInt(ceilVal);
        // 判断生成的金额等于0，便发0.01元
        if(val == 0){
           val = 1;
        }else if(val > totalVal){
            val = totalVal;
        }
        totalVal = totalVal - val;
        return val/100.0;
    }
}

人： 人在这里用线程代替

public class UserThread3 implements Runnable{
    private HongBao3 hongBao3;

    public UserThread3(HongBao3 hongBao3) {
        this.hongBao3 = hongBao3;
    }

    @Override
    public void run() {
        double money = hongBao3.getRandomMoney();
        if(money == 0) {
            System.out.println(Thread.currentThread().getName() + "不好意思，您手慢了！");
        }else {
            System.out.println(Thread.currentThread().getName() + "抢到 " + money + "元");
        }

    }
}

抢红包： 启动多个线程抢红包

public class QiangHongBao {
    public static void main(String[] args) {
    
        HongBao3 hongBao3 =new HongBao3(29,6);

        UserThread3 user3 = new UserThread3(hongBao3);
        for(int i=0;i<10;i++) {
            new Thread(user3).start();
        }
    }
}

第四种：总金额不限,红包限额，红包数不限，有多少人抢发多少个

红包： 在抢红包的过程中剩余金额会不断减少，要保证不能两个人同时抢，需要加上悲观锁，同一时间只可以一个人抢，加synchronized锁

public class HongBao4 {
    private int ceilVal;//红包最高额度*100 取整
   

    public HongBao4(double ceil) {
        this.ceilVal = (int) ceil*100;
      
    }

    public synchronized double getRandomMoney(){
        int val;//每个人分配到的金额*100
        val = new Random().nextInt(ceilVal);
        return val/100.0;
    }
}

人： 人在这里用线程代替

public class UserThread4 implements Runnable{
    private HongBao4 hongBao4;

    public UserThread4(HongBao4 hongBao4) {
        this.hongBao4 = hongBao4;
    }

    @Override
    public void run() {
        double money = hongBao4.getRandomMoney();
        System.out.println(Thread.currentThread().getName() + "抢到 " + money + "元");
    }
}

抢红包： 启动多个线程抢红包

public class QiangHongBao {
    public static void main(String[] args) {
        HongBao4 hongBao4 =new HongBao4(29);

        UserThread4 user4 = new UserThread4(hongBao4);
        for(int i=0;i<10;i++) {
            new Thread(user4).start();
        }
    }
}

其他要素

微信抢红包当然不仅仅是这样。在互联网时代高并发随处可见，抢红包也是一个高并的典型事件。主要借助mq（如：RabbitMQ）把抢红包的请求队列化，根据顺序获取红包金额（其中可以设置各种限制条件如：每人多少个，隔多少秒后才可以继续抢）。

通过时间复杂度看程序

微信抢红包中其实可以分成两大部分，1.用户抢红包算法分配金额，2.微信金额到账。
其中微信金额到账需要调用微信接口。接口中有大量的各种安全、信息相关的算法。时间复杂度相比第一部分高多了。所有抢红包程序通常因此崩溃。
市面通常解决办法：（类最终一致性）先完成第一部分保存数据并提示用户已获得红包金额，在 计算机有富余能力后才开始调用微信金额到账。
（如：春晚红包24小时内到账，游戏活动装备7天内到账）

IManiy
关注
专栏目录
JAVA作业——多线程抢红包
Evrse的博客
03-27 6667
JAVA作业——抢红包大体思路代码实现 大体思路 红包的分发见JAVA作业——红包分发。 而抢红包要解决的是线程问题。 其实比较简单，设定好人数，每个人一个线程，每个线程执行一遍，有红包就抢，没有红包就抢不到，所以run函数中只要判断现在还有没有红包就可以了。 代码实现 import java.util.Random; import java.util.Scanner; public class Main { public static void main(String[] args) {
春晚微信红包，是怎么扛住一百亿次请求的
j15398699939的专栏
07-29 1196
出处：http://www.infoq.com/cn/articles/weixin-bonus-load?utm_source=infoq&utm_medium=popular_widget&utm_campaign=popular_content_list&utm_content=homepage 编者按 “大牛V课堂”是Geekbang核心栏目，通过邀约专业领域内的互联网顶级大牛
【Java】微信抢红包的功能是如何实现的，如果让你来做你怎么设计？
alen101的博客
07-05 909
一、问题解析 实现拼手气红包算法，有以下几个需要注意的地方： 抢红包的期望收益应与先后顺序无关 保证每个用户至少能抢到一个预设的最小金额，人民币红包设置的最小金额一般是0.01元，如果需要发其他货币类型的红包，比如区块链货币或者积分，需要自定义一个最小金额。 所有抢红包的人领取的子红包的金额之和加起来，等于发红包的人发出的总红包的金额。 下面实现的方式是一次生成所有的子红包，让用户按顺序领取。也可以每领取一个生成一个，两种方式性能上各有优劣。 37.1 抢红包设计常见问题 37.1.1 微信的金额
java抢红包并发设计_java多线程模拟抢红包功能
weixin_29291573的博客
02-16 489
今天有朋友问我一道面试题，有5个人抢5个红包，可重复抢，用多线程程序实现，实现方式有多种，分享一下我的思路：应用了阻塞队列的特性。/*** Created by zhanglinqiang on 2016/6/23.*/public class MyTest {public static void main(String[] args) throws InterruptedException {L...
java抢红包_Java实现抢红包功能
weixin_42519781的博客
02-15 718
采用多线程模拟多人同时抢红包。服务端将玩家发出的红包保存在一个队列里，然后用Job定时将红包信息推送给玩家。每一批玩家的抢红包请求，其实操作的都是从队列中弹出的第一个红包元素，但当前的红包数量为空的时候，自动弹出下一个红包(如果有的话)。关键思想：1.抢红包涉及多人并发操作，需要做好同步保证多线程运行结果正确。2.由于同时在线人数大，从性能方面考虑，玩家的发红包请求不必及时响应，而由服务端定时执行...
java多线程模拟抢红包功能
08-28
主要介绍了java多线程模拟抢红包功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
java多线程实现抢红包
热门推荐
几人憔悴几人泪
10-29 1万+
在准备写这个代码之前，我着实的复习和加深了对线程操作的使用，同步和数据共享！ 说一下代码的思路： 首先抢红包，人、红包抽象为两个对象，人（获取到红包）红包（总额，数量，提供生成随机金额方法） 其中，生成随机红包有两种方案，第一种：获取的时候生成，第二种：先生成好所有的红包 对于两种方案都涉及到数据同步和共享，红包的总额就是一个共享数据，获取随机生成的红包金额方法需要加锁，保证生成随机金额时
JAVA实现简单抢红包算法(模拟真实抢红包)
08-31
在本文中，我们将深入探讨如何使用Java实现一个简单的抢红包算法，模拟真实的红包分配规则。首先，我们需要了解基本的逻辑和算法设计。 1. **红包总额与人数**：红包算法通常涉及两个关键参数：红包总额（mmm）和抢...
聊天软件抢红包实现思路与代码
02-04
下面将详细介绍“聊天软件抢红包实现思路与代码”，并探讨如何支持手机息屏抢红包和屏蔽群抢红包。 首先，我们需要理解红包的基本逻辑。红包通常由发送者创建，包含一定金额和红包个数。当红包被发布到聊天群或者...
Android-java实现仿照微信抢红包算法
08-13
在Android平台上，使用Java语言实现仿照微信抢红包算法是一个常见的编程挑战，它涉及到随机数生成、并发控制以及数据计算等多个技术领域。微信抢红包算法的核心在于公平性和随机性，确保每个用户在合法范围内有相等...
红包随机算法实现
08-15
下面将详细讲解如何使用Java实现一个公平的红包随机分配算法。 1. **红包算法的基本原理** 红包算法的核心是确保每个用户在抢红包时，无论先抢后抢，其获得的金额期望值大致相同。为了实现这个目标，我们需要考虑...
多线程抢红包带SwingUI
07-13
一个自己写的实现了多线程加上线程间通信机制的抢红包小程序，采用了Swing界面，非常适合学习线程和应付小作业。
微信抢红包java代码及demo和说明（收集待学习）
03-27
微信抢红包java代码及demo和说明
Java代码实现微信红包功能
06-25
为了实现随机分配金额，我们需要引入随机数生成算法，如Java的`Random`类。 其次，`Swing`是Java用于构建图形用户界面（GUI）的库，我们将用它来设计客户端界面。`JFrame`是主窗口，`JButton`用于创建按钮（如“发...
Java 多线程抢红包
分享我的点点滴滴，在成长路上与你同行！
05-22 569
Java 多线程抢红包
微信抢红包算法 java_java 实现仿照微信抢红包算法，实测结果基本和微信吻合，附demo...
weixin_34901508的博客
02-13 302
实现拼手气红包算法，有以下几个需要注意的地方：抢红包的期望收益应与先后顺序无关保证每个用户至少能抢到一个预设的最小金额，人民币红包设置的最小金额一般是0.01元，如果需要发其他货币类型的红包，比如区块链货币或者积分，需要自定义一个最小金额。所有抢红包的人领取的子红包的金额之和加起来，等于发红包的人发出的总红包的金额。下面实现的方式是一次生成所有的子红包，让用户按顺序领取。也可以每领取一个生成一个，...
Java多线程实现简单抢红包
weixin_40932275的博客
07-20 1108
抢红包是在并发场景下操纵和获取资源，只需要将操作和获取的过程建立线程安全机制即可； 抢红包需要多线程同时访问同一共享资源，所以将共享资源作为成员变量注入线程类中供其调用 (使用操纵内存的方式)； 实现过程 红包类： // 红包实体，共享变量，通过直接操作内存实现 public class RedPack{ // 红包剩余数量 int remain; // 总...
【Java】多线程综合练习：抢红包
最新发布
qq_39921135的博客
07-16 339
写完后发现，虽然逻辑对了，数据好像也没有什么太大问题，但是跟实际生活好像有一点不一样，在实际生活中，应该保留小数点后面两位，我要进行精确计算怎么办？，如果你传递 100，它就会在100中随机，随机的时候是带小数的，只不过这个方法在JDK17的时候才能用，低版本用不了。运行程序，这就是我们想要的结果，三个人抢到了，两个人没有抢到，而且三个人的总金额是100元。在用起来的时候非常难受，非常不方便，它里面加减乘除所有的全部都是使用方法来实现的。因此我们还需要将这个代码去改一改，改成精确运算就行了，即使用。
java多线程抢红包_Java线程操作-模拟本地多线程抢红包
weixin_42355204的博客
02-25 294
没有写过抢红包的处理程序，考虑到多线程是核心，所以练习先写一个本地使用多线程来抢红包的模拟程序。程序运行要达到的效果，是最终红包都被抢完，并对数据进行统计，统计结果和总库存要完全吻合。没有过多的解释，直接就一个测试类。package com.chris.java;import java.util.HashMap;import java.util.Map;/*** Created by Chris ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值