问题：快速产生一亿随机数据，筛选1亿随机数最大的100个数

最新推荐文章于 2021-01-19 02:53:22 发布
最新推荐文章于 2021-01-19 02:53:22 发布
阅读量1k 收藏 1
点赞数
分类专栏： 每日工作学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28027543/article/details/103492463
版权

原始数据模拟

单个线程产生数据

  • 数据格式，每个数字8BYTE，换行符\r\n 2BYTE
   File file = new File("test.txt");
        FileWriter fileWriter = new FileWriter(file, false);
        int i=1;
        Random random = new Random();
        while (i<=Threshould){
            int i1 = random.nextInt(Threshould) ;
            String s = String.format("%08d", i1) + "\r\n";
            fileWriter.write(s);
            i++;
        }
        fileWriter.close();
        System.out.println("size ="+file.length());

单个线程产生数据

多个线程产生数据（每个线程负责文件的一部分）

public static void writeP() throws IOException, InterruptedException {
        File file = new File("testP.txt");
        if(file.isFile()) {
            file.delete();
        }
        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
        FileChannel channel = randomAccessFile.getChannel();
        ExecutorService executorService = Executors.newFixedThreadPool(java.lang.Runtime.getRuntime().availableProcessors());
        long position=0;
        long size=(Threshould*10)/Rounds;
        long num=Threshould/Rounds;
        for(int i=0;i<Rounds;i++){
            long finalPosition = position;
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        Random random = new Random();
                        MappedByteBuffer map = channel.map(FileChannel.MapMode.READ_WRITE, finalPosition, size);
                        for (int i=0;i<num;i++) {
                            int i1 = random.nextInt(Threshould);
                            String s = String.format("%08d", i1) + "\r\n";
                            map.put(s.getBytes());
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            });
            position+=size;
        }
            executorService.shutdown();
        while (!executorService.awaitTermination(10, TimeUnit.MILLISECONDS)) {
        }
        channel.close();
        System.out.println("size ="+file.length());
    }

在这里插入图片描述

筛选1亿随机数最大的100个数

  • 使用原始数据材料
    在这里插入图片描述

SPSC - 单生产者单消费者模式

  public void findMax0(String path,int MaxNum) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(new File(path)));
        int[] maxNum = new int[MaxNum];
        String s="";int i=0;
        while ((s!=null)){
            s = bufferedReader.readLine();
            if (s==null){
                System.out.println("Count of Num: "+i);
                break;
            }
            Integer integer = Integer.valueOf(s);
            insert(maxNum,integer);
            i++;
        }
        System.out.println("maxNum:");
        for (int a:maxNum){
            System.out.print(a+" - ");
        }
    }

在这里插入图片描述

SPMC - 单生产者多消费者模式

  public void findMaxBySPMC(String path,int MaxNum) throws IOException, InterruptedException {
        BufferedReader bufferedReader = new BufferedReader(new FileReader(new File(path)));
        String s="";int i=0;
        int[] last=new int[RoundCount];
        int[] MaxAll=new int[MaxNum];
        AtomicInteger Position = new AtomicInteger(0);
        ExecutorService executorService = Executors.newFixedThreadPool(java.lang.Runtime.getRuntime().availableProcessors());
        HashMap<String, Long> hashMap = new HashMap<>();
       for(int K=1;K<=12;K++){
           String threadName="pool-1-thread-"+K;
           hashMap.put(threadName,0L);
       }
        // ExecutorService executorService = Executors.newFixedThreadPool(1);
        class findMaxTask implements Runnable{
            private int[]arr;
            private int[] maxNum;
            public findMaxTask(int[] arr,int[]maxNum){
                this.arr=arr;
                this.maxNum=maxNum;
            }
            @Override
            public void run() {
                long start = System.currentTimeMillis();
                for (int i = 0;i<arr.length;i++) {
                    insert(maxNum,arr[i]);
                }
                for(int i=0;i<MaxNum;i++){
                    last[Position.getAndIncrement()]=maxNum[i];
                }
                long end = System.currentTimeMillis();
                Long aLong = hashMap.get(Thread.currentThread().getName());
                hashMap.put(Thread.currentThread().getName(),aLong+end-start);

            }
        }
        int[] ints=new int[RoundCount];int rounds=0;
        // while ((s!=null)&&rounds<2){
        while ((s!=null)){
            s = bufferedReader.readLine();
            //最后一次可能不满数组
            if (s==null){
                System.out.println("file end ###"+" []Length : "+i);
                if (i!=0) {
                    findMaxTask findMaxTask = new findMaxTask(ints,new int[MaxNum]);
                    rounds++;
                    executorService.submit(findMaxTask);
                }
                break;
            }
            Integer integer = Integer.valueOf(s);
            ints[i]=integer;
            i++;
            if (i>=ints.length) {
                findMaxTask findMaxTask = new findMaxTask(ints,new int[MaxNum]);
                executorService.submit(findMaxTask);
                i=0;
                int[] ints0=new int[RoundCount];
                ints=ints0;
                rounds++;
            }
        }
        while (Position.get()<last.length){

        }
        System.out.println("last task start");
        findMaxTask findMaxTask = new findMaxTask(last,MaxAll);
        executorService.submit(findMaxTask);
        executorService.shutdown();
        while (!executorService.awaitTermination(10, TimeUnit.MILLISECONDS)) {
        }

        System.out.println("MaxAll:");
        for (int a:MaxAll){
            System.out.print(a+" - ");
        }
        System.out.println("");
        long sum=0;
        for (Map.Entry<String ,Long> entry:hashMap.entrySet()){
            System.out.println(entry.getKey()+" Occupy time :"+entry.getValue()+"ms");
            sum+=entry.getValue();
        }
        System.out.println("sum of Occupy time: "+sum+"ms");
    }

在这里插入图片描述

  • 并未显著提高效率，多个写线程只占有很少一部分时间，大部分在等待读线程提供数据。

MPMC - 多生产者多消费者模式

 public void findMaxByMPMC(String file,int MaxNum) throws IOException, InterruptedException {
        int[] last=new int[RoundCount];
        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
        FileChannel channel = randomAccessFile.getChannel();
        int findMaxThreadNum = java.lang.Runtime.getRuntime().availableProcessors()-readFileThreadNum;
        ExecutorService executorReadFileService = Executors.newFixedThreadPool(readFileThreadNum);
        ExecutorService executorFindMaxService = Executors.newFixedThreadPool(findMaxThreadNum);
        HashMap<String, Long> readFileMap = new HashMap<>();
        for(int K=1;K<=readFileThreadNum;K++){
            String threadName="pool-1-thread-"+K;
            readFileMap.put(threadName,0L);
        }
        HashMap<String, Long> findMaxMap = new HashMap<>();
        for(int K=1;K<=findMaxThreadNum;K++){
            String threadName="pool-2-thread-"+K;
            findMaxMap.put(threadName,0L);
        }
        long position=0;
        long size=(Threshould*dataSize)/ReadTaskNum;
        long num=Threshould/ReadTaskNum;
        for(int i=0;i<ReadTaskNum;i++){
            ReadTask readTask = new ReadTask(channel, size, position, executorFindMaxService,last,readFileMap,findMaxMap);
            executorReadFileService.submit(readTask);
            position+=size;
        }
        executorReadFileService.shutdown();
        while (Position.get()<last.length){

        }
        System.out.println("last task start");
        findMaxTask findMaxTask = new findMaxTask(last,MaxAll,last,findMaxMap);
        executorFindMaxService.submit(findMaxTask);
        executorFindMaxService.shutdown();
        while (!executorReadFileService.awaitTermination(10, TimeUnit.MILLISECONDS)) {
        }
        while (!executorFindMaxService.awaitTermination(10, TimeUnit.MILLISECONDS)) {
        }
        System.out.println("MaxAll:");
        for (int a:MaxAll){
            System.out.print(a+" - ");
        }
        System.out.println("");
        long sum=0;
        for (Map.Entry<String ,Long> entry:readFileMap.entrySet()){
            System.out.println("readFileMap:"+entry.getKey()+" Occupy time :"+entry.getValue()+"ms");
            sum+=entry.getValue();
        }
        System.out.println("readFileMap:sum of Occupy time: "+sum+"ms");
        sum=0;
        for (Map.Entry<String ,Long> entry:findMaxMap.entrySet()){
            System.out.println("findMaxMap:"+entry.getKey()+" Occupy time :"+entry.getValue()+"ms");
            sum+=entry.getValue();
        }
        System.out.println("findMaxMap:sum of Occupy time: "+sum+"ms");

    }

  • 大致流程为：先把1亿数据分为10份，每份1千万个数，每个数据占10字节一共1亿字节，通过偏移量就可以很快的分割数据了。
    -主线程 产生10个ReadTask，交给生产者执行。

  • 每份数据由生产者线程处理，生产者线程每次获取到10万个数就生成一个分析任务，由分析线程池执行。

  • 每个生产者产生100个findMaxtask，交给消费者执行。

  • 10（生产者）*100（findMaxTask）*100（每个findMaxTask获得最大100个数）=10万个数

  • 最后一个任务–》从这10万个个数获得最大的100个数

  • 调整生产者：消费者比例，统计时间消耗

  • 调整生产者：消费者比例=1:11
    在这里插入图片描述
  • 调整生产者：消费者比例=2:10
    在这里插入图片描述
  • 调整生产者：消费者比例=3:9
    在这里插入图片描述
  • 调整生产者：消费者比例=4:8
    *在这里插入图片描述
  • 调整生产者：消费者比例=5:7
    *在这里插入图片描述
  • 调整生产者：消费者比例=6:6
    *
  • 调整生产者：消费者比例=7:5
    在这里插入图片描述
  • 调整生产者：消费者比例=8:4
    在这里插入图片描述
  • 调整生产者：消费者比例=9:3
    在这里插入图片描述
  • 调整生产者：消费者比例=10:2
    在这里插入图片描述
  • 调整生产者：消费者比例=11:1
    在这里插入图片描述
  • 消耗时间表
    在这里插入图片描述
  • 在10个生产者线程是消耗时间有一个大的下降，由于任务分成10份，刚好同时启动，效率提高很多

如果是1000亿数据呢，一台机器都无法储存下，获取最大k个数（topk问题）

  • 自然而然的想到每个机器合并一部分之后合并，这就是Mapreduce的思想
  • hadoop单机Mapreduce方法
  • 未完待续
qq_28027543
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA:实现递归形式FindMax查找最大值算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-11 355
JAVA:实现递归形式FindMax查找最大值算法(附完整源码)
从一亿个ip找出出现次数最多的IP(分治法)
阳光心态，健康人生的博客
05-21 6744
/* 1,hash散列 2,找到每个块出现次数最多的(默认出现均匀)—–&gt;可以用字典树 3,在每个块出现最多的数据中挑选出最大的为结果 */ 问题一： 怎么在海量数据中找出重复次数最多的一个 算法思想： 方案1：先做hash，然后求模映射为小文件，求出每个小文件中重复次数最多的一个，并记录重复次数。 然后找出上一步求出的数据中...
随机生成1亿个1~999以内的奇数，存储到列表中，考虑程序效率
qq_42449963的博客
05-13 508
代码： // 把1~999之间的奇数放在list集合中 List<Integer> list = new ArrayList<Integer>(); for (int i = 1; i <= 999; i++){ if(i % 2 == 1){ list.add(i); } } // 新建crazyList集合去存储1亿个1~999之间的奇数 List<Integer> crazyList = new ArrayList<I
1_1. 产生100个随机数_求其最小值和最大值以及平均值_
10-03
以下是一个简单的脚本示例： ```python import random # 生成100个0到100之间的随机整数 random_numbers = [random.randint(0, 100) for _ in range(100)] # 计算最小值、最大值和平均值 min_value = min(random_...
Python使用当前时间、随机数产生一个唯一数字的方法
09-21
为了测试在极短时间内（例如1秒内）生成的唯一数字是否真的不重复，可以使用一个循环来模拟多个并发请求。在给出的示例中，使用`for`循环生成了10个测试用例，所有结果均未发现重复。 ```python for _ in range(10)...
Java如何获取一个随机数 Java猜数字小游戏
08-24
这里，我们使用了类型转换，将 double 类型的值转换为 int 类型，并将其乘以 100 再加 1，以生成一个 1-100 之间的随机数。 三、猜数字小游戏 下面是一个猜数字小游戏的示例代码： ```java import java.util....
suijishu.rar_伪随机_伪随机数_线性同余_随机数产生_随机数生成
09-24
2. **计算**：根据线性同余方程计算下一个数 X1，然后用 X1 替换 X0，以此类推，不断生成新的伪随机数。 3. **质量检查**：生成的序列需要通过一系列统计测试，如Diehard测试和NIST的统计测试套件，以确保其随机性。...
怎么在海量数据中找出重复次数最多的一个
热门推荐
__技术分享__部落格
02-22 5万+
1、海量日志数据，提取出某日访问百度次数最多的那个IP。 　　此题，在我之前的一篇文章算法里头有所提到，当时给出的方案是：IP的数目还是有限的，最多2^32个，所以可以考虑使用hash将ip直接存入内存，然后进行统计。 　　再详细介绍下此方案：首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有个2^32个 IP。同样可以采用映射的方法
java一亿数字取前100个（3秒钟获取）
05-04
java一亿数字取前100个（3秒钟获取） 速度非常快。 发出来给大家分享
从一亿个数中找出最大的100个 或者n个
03-19
从一亿个数中找出最大的100个 或者n个 用了个堆
从十亿数据中找出出现最多的数以及出现次数
苏湘的专栏
10-13 8085
package org.example.bigdata; import java.util.Collections; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; public class TopTimes { public static
海量数据处理:有1亿个浮点数,找出其中最大的10000个
李俊标的博客
06-15 4946
第一种方法是将数据全部排序,然后在排序后的集合中进行查找,最快的排序算法的时间复杂度一般为O(nlogn),例如快速排序.而在32位机器上,每个float类型占4B,1亿个浮点数就要占用400M的存储空间,对于一些可以内存小于400MB的计算机而言,显然是不能一次将全部数据读入内存进行排序的.其实即使内存能满足要求,该方法也不高效,因为题目的目的是寻找出最大的10000个数即可,而排序是将所有元素...
现在有1千万个随机数，随机数的范围在1到1亿之间。现在要求写出一种算法，将1到1亿之间没有在随机数中的数求出来...
xiaomin1991222的专栏
07-24 238
package data.BitSet; import java.io.IOException;import java.util.Random; public class Data {   public static void main(String[] args)throws Exception {  test(); }  /**  * 求反交集  * @throws IOExceptio...
查找1亿个数里面最大的100个数。
星辰大海
03-31 2166
#include #include #include #include #include #include #include using namespace std; int main() { vector a(100000000,0); srand((int)time(0)); for(int i=0;i<100000000;i++) {
从10亿个数字中找出最大的前100个数
haitaobiyao的博客
06-06 4353
先拿10000个数建堆，然后一次添加剩余元素，如果大于堆顶的数（10000中最小的），将这个数替换堆顶，并调整结构使之仍然是一个最小堆，这样，遍历完后，堆中的10000个数就是所需的最大的10000个。建堆时间复杂度是O（mlogm），算法的时间复杂度为O（nmlogm）（n为10亿，m为10000）。 优化的方法：可以把所有10亿个数据分组存放，比如分别放在1000个文件中。这样处理就可以分别在每个文件的10^6个数据中找出最大的10000个数，合并到一起在再找出最终的结果。 ...
mysql一千万数据建立索引_千万级MySQL数据库建立索引及提高性能的手段
weixin_35980523的博客
01-19 1654
一、注意事项：首先，应当考虑表空间和磁盘空间是否足够。我们知道索引也是一种数据，在建立索引的时候势必也会占用大量表空间。因此在对一大表建立索引的时候首先应当考虑的是空间容量问题。其次，在对建立索引的时候要对表进行加锁，因此应当注意操作在业务空闲的时候进行。二、性能调整方面：首当其冲的考虑因素便是磁盘I/O。物理上，应当尽量把索引与数据分散到不同的磁盘上(不考虑阵列的情况)。逻辑上，数据表空间与索引...
一个随机生成1到100随机数的VB程序
最新发布
07-14
下面是一个生成1到100之间随机数的 Visual Basic 程序示例： ```vb Imports System Module Program Sub Main(args As String()) Dim rand As New Random() Dim randomNumber As Integer = rand.Next(1, 101) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值