如何用 Java 几分钟处理完 30 亿个数据?

如何用java几分钟处理完30亿个数据 *** 按照 x坐标 来分割 字符串,如果切到的字符不为“,”, 那么把坐标向前或者向后移动一位。** @param arr 存放x1,x2坐标* @return*/}}= ',') {}if (end! 阅读详情

1. 场景说明

现有一个 10G 文件的数据,里面包含了 18-70 之间的整数,分别表示 18-70 岁的人群数量统计。假设年龄范围分布均匀,分别表示系统中所有用户的年龄数,找出重复次数最多的那个数,现有一台内存为 4G、2 核 CPU 的电脑,请写一个算法实现。

23,31,42,19,60,30,36,........

2. 模拟数据
 

Java 中一个整数占 4 个字节,模拟 10G 为 30 亿左右个数据, 采用追加模式写入 10G 数据到硬盘里。

每 100 万个记录写一行,大概 4M 一行,10G 大概 2500 行数据。

package bigdata; import java.io.*;import java.util.Random; /** * @Desc: * @Author: bingbing * @Date: 2022/5/4 0004 19:05 */public class GenerateData {    private static Random random = new Random();     public static int generateRandomData(int start, int end) {        return random.nextInt(end - start + 1) + start;    }     /**     * 产生10G的 1-1000的数据在D盘     */    public void generateData() throws IOException {        File file = new File("D:\\ User.dat");        if (!file.exists()) {            try {                file.createNewFile();            } catch (IOException e) {                e.printStackTrace();            }        }         int start = 18;        int end = 70;        long startTime = System.currentTimeMillis();        BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file, true)));        for (long i = 1; i < Integer.MAX_VALUE * 1.7; i++) {            String data = generateRandomData(start, end) + ",";            bos.write(data);            // 每100万条记录成一行,100万条数据大概4M            if (i % 1000000 == 0) {                bos.write("\n");            }        }        System.out.println("写入完成! 共花费时间:" + (System.currentTimeMillis() - startTime) / 1000 + " s");        bos.close();    }     public static void main(String[] args) {        GenerateData generateData = new GenerateData();        try {            generateData.generateData();        } catch (IOException e) {            e.printStackTrace();        }    }}

上述代码调整参数执行 2 次,凑 10G 数据在 D 盘 User.dat 文件里:

准备好 10G 数据后,接着写如何处理这些数据。

3. 场景分析
 

10G 的数据比当前拥有的运行内存大的多,不能全量加载到内存中读取。如果采用全量加载,那么内存会直接爆掉,只能按行读取。Java 中的 bufferedReader 的 readLine() 按行读取文件里的内容。

4. 读取数据
 

首先,我们写一个方法单线程读完这 30 亿数据需要多少时间,每读 100 行打印一次:

private static void readData() throws IOException {    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(FILE_NAME), "utf-8"));    String line;    long start = System.currentTimeMillis();    int count = 1;    while ((line = br.readLine()) != null) {        // 按行读取        if (count % 100 == 0) {            System.out.println("读取100行,总耗时间: " + (System.currentTimeMillis() - start) / 1000 + " s");            System.gc();        }        count++;    }    running = false;    br.close();}

按行读完 10G 的数据大概 20 秒,基本每 100 行,1 亿多数据花 1 秒,速度还挺快。

5. 处理数据

5.1 思路一
 

通过单线程处理,初始化一个 countMap,key 为年龄,value 为出现的次数。将每行读取到的数据按照 "," 进行分割,然后获取到的每一项进行保存到 countMap 里。如果存在,那么值 key 的 value+1。

for (int i = start; i <= end; i++) {    try {        File subFile = new File(dir + "\\" + i + ".dat");        if (!file.exists()) {            subFile.createNewFile();        }        countMap.computeIfAbsent(i + "", integer -> new AtomicInteger(0));    } catch (FileNotFoundException e) {        e.printStackTrace();    } catch (IOException e) {        e.printStackTrace();    }}

单线程读取并统计 countMap:

publicstatic void splitLine(String lineData) {    String[] arr = lineData.split(",");    for (String str : arr) {        if (StringUtils.isEmpty(str)) {            continue;        }        countMap.computeIfAbsent(str, s -> new AtomicInteger(0)).getAndIncrement();    }}

通过比较找出年龄数最多的年龄并打印出来:

private static void findMostAge() {    Integer targetValue = 0;    String targetKey = null;    Iterator<Map.Entry<String, AtomicInteger>> entrySetIterator = countMap.entrySet().iterator();    while (entrySetIterator.hasNext()) {        Map.Entry<String, AtomicInteger> entry = entrySetIterator.next();        Integer value = entry.getValue().get();        String key = entry.getKey();        if (value > targetValue) {            targetValue = value;            targetKey = key;        }    }    System.out.println("数量最多的年龄为:" + targetKey + "数量为:" + targetValue);}

测试结果
 

总共花了 3 分钟读取完并统计完所有数据。

内存消耗为 2G-2.5G,CPU 利用率太低,只向上浮动了 20%-25% 之间。

要想提高 CPU 利用率,那么可以使用多线程去处理。
 

下面我们使用多线程去解决这个 CPU 利用率低的问题。

5.2 思路二:分治法

使用多线程去消费读取到的数据。采用生产者、消费者模式去消费数据。

因为在读取的时候是比较快的,单线程的数据处理能力比较差。因此思路一的性能阻塞在取数据的一方且又是同步操作,导致整个链路的性能会变的很差。


所谓分治法就是分而治之,也就是说将海量数据分割处理。 根据 CPU 的能力初始化 n 个线程,每一个线程去消费一个队列,这样线程在消费的时候不会出现抢占队列的问题。同时为了保证线程安全和生产者消费者模式的完整,采用阻塞队列。Java 中提供了 LinkedBlockingQueue 就是一个阻塞队列。

初始化阻塞队列
 

使用 LinkedList 创建一个阻塞队列列表:

private static List<LinkedBlockingQueue<String>> blockQueueLists = new LinkedList<>();

在 static 块里初始化阻塞队列的数量和单个阻塞队列的容量为 256。

上面讲到了 30 亿数据大概 2500 行,按行塞到队列里。20 个队列,那么每个队列 125 个,因此可以容量可以设计为 256 即可。

//每个队列容量为256for (int i = 0; i < threadNums; i++) {    blockQueueLists.add(new LinkedBlockingQueue<>(256));}

生产者
 

为了实现负载的功能,首先定义一个 count 计数器,用来记录行数:

private static AtomicLong count = new AtomicLong(0);

按照行数来计算队列的下标 long index=count.get()%threadNums。 

下面算法就实现了对队列列表中的队列进行轮询的投放:

static class SplitData {    public static void splitLine(String lineData) {        String[] arr = lineData.split("\n");        for (String str : arr) {            if (StringUtils.isEmpty(str)) {                continue;            }            long index = count.get() % threadNums;            try {                // 如果满了就阻塞                blockQueueLists.get((int) index).put(str);            } catch (InterruptedException e) {                e.printStackTrace();            }            count.getAndIncrement();        }    }

消费者


1) 队列线程私有化
 

消费方在启动线程的时候根据 index 去获取到指定的队列,这样就实现了队列的线程私有化。

private static void startConsumer() throws FileNotFoundException, UnsupportedEncodingException {    //如果共用一个队列,那么线程不宜过多,容易出现抢占现象    System.out.println("开始消费...");    for (int i = 0; i < threadNums; i++) {        final int index = i;        // 每一个线程负责一个 queue,这样不会出现线程抢占队列的情况。        new Thread(() -> {            while (consumerRunning) {                startConsumer = true;                try {                    String str = blockQueueLists.get(index).take();                    countNum(str);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        }).start();        }}

2) 多子线程分割字符串

由于从队列中多到的字符串非常的庞大,如果又是用单线程调用 split(",") 去分割,那么性能同样会阻塞在这个地方。

// 按照 arr的大小,运用多线程分割字符串private static void countNum(String str) {    int[] arr = new int[2];    arr[1] = str.length() / 3;    for (int i = 0; i < 3; i++) {        final String innerStr = SplitData.splitStr(str, arr);        new Thread(() -> {            String[] strArray = innerStr.split(",");            for (String s : strArray) {                countMap.computeIfAbsent(s, s1 -> new AtomicInteger(0)).getAndIncrement();            }        }).start();    }}

3) 分割字符串算法
 

分割时从 0 开始,按照等分的原则,将字符串 n 等份,每一个线程分到一份。

用一个 arr 数组的 arr[0] 记录每次的分割开始位置。arr[1] 记录每次分割的结束位置,如果遇到的开始的字符不为 "," 那么就 startIndex-1。如果结束的位置不为 "," 那么将 endIndex 向后移一位。

如果 endIndex 超过了字符串的最大长度,那么就把最后一个字符赋值给 arr[1]。

/** * 按照 x坐标 来分割 字符串,如果切到的字符不为“,”, 那么把坐标向前或者向后移动一位。 * * @param line * @param arr  存放x1,x2坐标 * @return */public static String splitStr(String line, int[] arr) {    int startIndex = arr[0];    int endIndex = arr[1];    char start = line.charAt(startIndex);    char end = line.charAt(endIndex);    if ((startIndex == 0 || start == ',') && end == ',') {        arr[0] = endIndex + 1;        arr[1] = arr[0] + line.length() / 3;        if (arr[1] >= line.length()) {            arr[1] = line.length() - 1;        }        return line.substring(startIndex, endIndex);    }
    if (startIndex != 0 && start != ',') {        startIndex = startIndex - 1;    }
    if (end != ',') {        endIndex = endIndex + 1;    }
    arr[0] = startIndex;    arr[1] = endIndex;    if (arr[1] >= line.length()) {        arr[1] = line.length() - 1;    }    return splitStr(line, arr);}

测试结果

内存和 CPU 初始占用大小:

启动后,运行时内存稳定在 11.7G,CPU 稳定利用在 90% 以上。

总耗时由 180 秒缩减到 103 秒,效率提升 75%,得到的结果也与单线程处理的一致。

6. 遇到的问题

如果在运行了的时候,发现 GC 突然罢工不工作了,有可能是 JVM 的堆中存在的垃圾太多,没回收导致内存的突增。

解决方法

在读取一定数量后,可以让主线程暂停几秒,手动调用 GC。

遇到海量数据时,用JAVA如何在几分钟处理完30亿个数据? 一、场景说明 现有一个10G文件的数据,里面包含了18-70之间的整数,分别表示18-70岁的人群数量统计,假设年龄范围分布均匀,分别表示系统中所有用户的年龄数,找出重复次数最多的那个数,现有一台内存为4G、2核CPU的电脑,请写一个算法实现。 23,31,42,19,60,30,36,........ 二、模拟数据 Java中一个整数占4个字节,模拟10G为30亿左右个数据, 采用追加模式写入10G数据到硬盘里。 每100万个记录写一行,大概4M一行,10G大概2500行数据。 pack 阅读详情

相关推荐

【AAAI 2025】轻量级特征增强新范式!FCM 模块助力小目标检测,即插即用提升模型泛化能力

本文介绍了AAAI 2025提出的轻量级特征增强新范式FCM模块,它通过显式分离并双向交互语义与空间特征,有效解决了小目标检测中特征信息失配的核心难题。该模块设计精巧,计算开销极低,能够即插即用式地嵌入YOLO等主流检测网络,显著提升模型对小目标的泛化检测能力,尤其适用于遥感、自动驾驶等对计算资源敏感的实际场景。

weixin_29056145的博客 291

如何用 Java 几分钟处理完 30 亿个数据

如何用 Java 几分钟处理完 30 亿个数据

吴名氏的博客 1万+

麒麟V10(arm)配置本地离线yum源

麒麟V10(arm)配置本地离线yum源

myfm2java的博客 7895

如何用 Java 几分钟处理完 30 亿个数据?

程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 7分钟。来自:blog.youkuaiyun.com/qq_33036061/article/details/1245686891. 场景说明现有一个 10G 文件的数据,里面包含了 18-70 之间的整数,分别表示 18-70 岁的人群数量统计。假设年龄范围分布均匀,分别表示系统中所有用户的年龄数,找出重复次数最多的那个数,现有一台内存...

良月柒 256

HDMI设计2----EDID and E-EDID

1,EDID是什么?有什么用? 图1 应用场景 如图1所示的应用场景,PC将视频信号发送 到我们的设备上,经过一系列的传输和切换,设备将视频信号发送到显示器或者投影机上,也就是说,我们的设备位于PC和显示器之间。首先,在输入端,设备需要让PC知道自己是能够接受输入视频信号的,让PC认为自己是一台显示器。如果不这样做的话,PC可能会拒绝输出任何视频信号的(VGA接口不需要EDID也能输出)。除此之外,设备还要告诉PC自己支持的显示时序。而在输出端,当设备需要自建输出时序而不是简单的复制...

Archar_Saber的博客 7993

完整指南:从基础到高级使用 Semantic Kernel

通过本文的学习,你已经掌握了从基础到高级的使用方法。安装并配置。使用简单的文本生成和自然语言处理任务。利用任务链和工具扩展构建复杂的工作流。通过记忆管理上下文,创建更智能的应用。扩展多模态处理能力,集成图像和音频分析。将应用部署到云端,并通过 Azure Functions 提供智能服务。无论是构建简单的对话应用,还是创建多模态智能服务,都提供了强大的工具和灵活的扩展机制。希望这篇文章能帮助你更好地理解并运用这个框架,构建出更加智能和高效的应用。

net core ,前端 ,python 全栈开发 2807

如何用Java几分钟处理完30亿个数据?

来源:blog.youkuaiyun.com/qq_33036061/article/details/124568689场景说明现有一个 10G 文件的数据,里面包含了 18-70 之间的整数,分别表示 18-70 岁的人群数量统计,假设年龄范围分布均匀,分别表示系统中所有用户的年龄数,找出重复次数最多的那个数,现有一台内存为 4G、2 核 CPU 的电脑,请写一个算法实现。23,3...

458

Jasper Report使用JSON数据源创建报表

最近在做一个项目小功能,表单结案要生成PDF报表。 起初,想用HTML模板(art-template模板引擎)编写,利用浏览器的打印功能保存成pdf文件下载。但是HTML编写好的模板,页码、页眉、页脚设置有坑,表单内容中的表格较多,表格不能设置跨页,导致跨页的表格内容与页眉重叠,没能解决这个问题。 于是,转战研究Jasper report生成报表,用更加专业的报表生成工具来做。刚开始,也是跌跌撞撞,遇到了很多问题,因为觉得没有退路了,必须要用这个搞出来,所以就硬着头皮去找各种资料。 主要使用的json

xiaogege2012的专栏 3321

我用Java几分钟处理完30亿个数据...

*** 按照 x坐标 来分割 字符串,如果切到的字符不为“,”, 那么把坐标向前或者向后移动一位。* @param arr 存放x1,x2坐标* @return*/= ',') {if (end!= ',') {

程序员高级码农的博客 869

FPGA 学习笔记:解决FPGA程序固化重新上电程序不运行的问题

FPGA 学习笔记:解决FPGA程序固化重新上电程序不运行的问题

坚韧与专注 1万+

使用再生龙备份还原liunx系统(精确每一步)

再生龙镜像可自行到官网下载(ISO/ZIP格式均可),然后使用tuxboot烧录工具制作启动盘,另外准备一个U盘用来存储备份的镜像文件,即再生龙盘和存储盘是两个分开的。当然也可以用分区工具把同一个硬盘分区来使用,比较方便,先学会基本的吧,只是告诉有个捷径,省个U盘。

米可的博客! 8387

海量数据问题: 如何用JAVA几分钟处理完30亿个数据?

现有一个10G文件的数据,里面包含了18-70之间的整数,分别表示18-70岁的人群数量统计,假设年龄范围分布均匀,分别表示系统中所有用户的年龄数,找出重复次数最多的那个数,现有一台内存为4G、2核CPU的电脑,请写一个算法实现。采用生产者、消费者模式去消费数据,因为在读取的时候是比较快的,单线程的数据处理能力比较差,因此思路一的性能阻塞在取数据方,又是同步的,所以导致整个链路的性能会变的很差。如果在运行了的时候,发现GC突然罢工了,开始不工作了,有可能是JVM的堆中存在的垃圾太多,没回收导致内存的突增。

一个平平无奇的搬砖人 853

PCL点云库入门(第6讲)——PCL库中Eigen数学工具库的基本使用(持续更新)

Eigen库是一个高性能的C++模板库,专注于线性代数、矩阵和向量运算,以及相关的数值分析和算法。在Eigen库中,所有的矩阵和向量均被视为矩阵模板类的实例。向量可以被看作是特殊形式的矩阵,具体表现为只包含1行或1列。

qq_36812406的博客 1755

如何用JAVA几分钟处理完30亿个数据?

现有一个 10G 文件的数据,里面包含了 18-70 之间的整数,分别表示 18-70 岁的人群数量统计,假设年龄范围分布均匀,分别表示系统中所有用户的年龄数,找出重复次数最多的那个数,现有一台内存为 4G、2 核 CPU 的电脑,请写一个算法实现。...

java_beautiful的博客 195

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

上一篇: JAVA:面向对象++封装+继承【详细】
下一篇: Java集合之Set集合
javaYY_
博客等级 码龄4年 148粉丝 69原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值