1亿个数引发的思考（一）

1） 如何生成1亿随机数
答：生成有序数组，遍历时生成随机下标进行交换
2）存储1亿个数字文件多大？
答：约1G
3）1亿代表的是一类什么问题？
答：内存不够用的问题，因为内存不能无限扩张，数据却可以
4）内存不够用时怎么办？
答：借助外存，并充分利用内存
5）外存文件需要一开始就切割成小块，然后分别排序，再归并吗？
答：不一定，用RandomAccessFile流的形式加载文件,加载一部分排序一部分并输出为小文件，直到大文件加载完毕。
然后将所有小文件RandomAccessFile流的形式加载，进行N路归并，即所有小文件中最小的输出到大文件，并从小文件移除。
重复这个过程直到处理完毕所有小文件。
6）堆排序和归并排序设计思想有关联吗？
答：？？？
7）实现一个归并排序

具体实现

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import cn.hutool.core.util.RandomUtil;

public class MergeTest {

    // 1）生成大数组 
    // 2) 填充小数组，快排后转存
    // 3) N路归并
    // 4) 寻找重复
    public static void main(String[] args) throws IOException {
        
        //generate1yi();

        int piece = 0;
        int cap = 1000000;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        {
            System.out.println("拆分开始：" + sdf.format(new Date()));
            // 拆分
            BufferedReader br = new BufferedReader(new FileReader(new File("D://out/1yi.txt")));
            String line = null;
            int size = 0;
            List<Integer> list = new ArrayList<>();
            while ((line = br.readLine()) != null) {
                list.add(Integer.valueOf(line));
                size++;
                if (size == cap) {
                    size = 0;
                    split(list, piece++);
                    list = new ArrayList<>();
                }
            }
            if (size != 0) {
                split(list, piece++);
            }

            br.close();

            System.out.println("归并开始：" + sdf.format(new Date()));

        }

        {
            // N路归并
            Set<LineQueue> queueSet = new HashSet<>();
            for (int i = 0; i < piece; i++) {
                queueSet.add(new LineQueue("D://out/" + i + ".txt", "utf-8", 10000));
            }
            BufferedWriter bw = new BufferedWriter(new FileWriter(new File("D://out/1yi_ordered.txt")));
            for (;;) {
                LineQueue max = null;
                Integer i = null;
                List<LineQueue> removed = new ArrayList<>();
                for (LineQueue q : queueSet) {
                    Integer next = q.next(false);
                    if (next == null) {
                        // 一个基于文件行的阻塞管理，消费完毕后移除
                        removed.add(q);
                        continue;
                    }
                    if (i == null || next < i) {
                        i = next;
                        max = q;
                    }
                }

                if (removed.size() > 0) {
                    for (LineQueue q : removed) {
                        try {
                            q.close();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        queueSet.remove(q);
                    }
                    removed.clear();
                }

                if (max == null) {
                    break;
                }
                Integer next = max.next(true);
                max = null;
                i = 0;
                bw.append(next + "\r\n");
                // 逢1一千万打印日志
                if (next % 10000000 == 0) {
                    System.out.println("归并进度：" + sdf.format(new Date()) + "  >>>>" + next);
                }
            }

            bw.close();
        }

        // 比较相邻是否相同
        Integer last = null;
        Map<Integer, Integer> occur = new HashMap<>();
        System.out.println("遍历开始：" + sdf.format(new Date()));
        BufferedReader br = new BufferedReader(new FileReader(new File("D://out/1yi_ordered.txt")));
        String line = null;
        while ((line = br.readLine()) != null) {
            Integer curr = Integer.valueOf(line);
            if (last == null) {
                last = curr;
                continue;
            }
            if (curr.equals(last)) {
                Integer integer = occur.get(curr);
                if (integer == null) {
                    occur.put(curr, 2);
                } else {
                    occur.put(curr, integer + 1);
                }
            }
            last = curr;
        }
        br.close();
        System.out.println("处理结束：" + sdf.format(new Date()));
        System.out.println("重复数字：" + sdf.format(new Date()) + "  >>>>" + occur);
    }

    public static void split(List<Integer> list, int piece) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter(new File("D://out/" + piece + ".txt")));
        int[] arr = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            arr[i] = list.get(i);
        }
        quickSort(arr, "asc");
        for (int i : arr) {
            bw.append(i + "\r\n");
        }
        bw.flush();
        bw.close();
    }

    public static void quickSort(int arr[], String sortType) {
        quickSort(arr, 0, arr.length - 1, sortType);
    }

    // start vs end
    // low vs high
    // left vs right
    // 充分利用数组空间 （不管如何交换，数据都在）
    // 递归
    private static void quickSort(int[] arr, int l, int h, String t) {
        if (l >= h) {
            return;
        }
        int s = l;
        int e = h;
        boolean asc = "asc".equalsIgnoreCase(t);
        int b = arr[s];
        while (s < e) {
            for (; s < e; e--) {
                if (asc ? b > arr[e] : b < arr[e]) {
                    exchange(arr, s, arr[e], e, b);
                    break;
                }
            }
            for (; s < e; s++) {
                if (asc ? b < arr[s] : b > arr[s]) {
                    exchange(arr, e, arr[s], s, b);
                    break;
                }
            }
        }
        quickSort(arr, l, s - 1, t);
        quickSort(arr, s + 1, h, t);
    }

    static void exchange(int arr[], int a, int av, int b, int bv) {
        arr[a] = av;
        arr[b] = bv;
    }

    private static void generate1yi() throws IOException {

        int max = 10000 * 10000;
        int i1 = RandomUtil.randomInt(0, max);
        int i2 = RandomUtil.randomInt(0, max);

        int[] randomInts = RandomUtil.randomInts(max);
        File file = new File("D://out//1yi.txt");
        FileWriter fileWriter = new FileWriter(file);
        for (int i : randomInts) {
            fileWriter.append(i + "\r\n");
            if (i == i1) {
                fileWriter.append(666 + "\r\n");
            } else if (i == i2) {
                fileWriter.append(888 + "\r\n");
            }
        }
        fileWriter.close();
    }
}

 

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class LineQueue implements AutoCloseable {

    private Thread t;
    private BlockingQueue<Integer> q;
    private boolean f = false;
    
    public LineQueue(String file, String encoding, int capacity) {
        q = new ArrayBlockingQueue<Integer>(capacity);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try (BufferedReader bufferedReader = new BufferedReader(
                        new InputStreamReader(new FileInputStream(file), encoding));) {
                    String l;
                    while ((l = bufferedReader.readLine()) != null) {
                        q.put(Integer.valueOf(l));
                    }
                    f = true;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        t = new Thread(runnable);
        t.start();
    }

    public Integer next(boolean remove) {

        while (q.isEmpty() && !f) {
            try {
                Thread.sleep(10L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        try {
            if(remove) {
                return q.take();
            }else {
                return q.peek();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return null;
    }

    @Override
    public void close() throws Exception {
        if (q != null && !q.isEmpty()) {
            q.clear();
            t.interrupt();
        }
    }

}

 

 

输出结果：

拆分开始：2023-04-27 19:54:13
归并开始：2023-04-27 19:54:45
归并进度：2023-04-27 19:54:45  >>>>0
归并进度：2023-04-27 19:55:53  >>>>10000000
归并进度：2023-04-27 19:57:00  >>>>20000000
归并进度：2023-04-27 19:58:07  >>>>30000000
归并进度：2023-04-27 19:59:15  >>>>40000000
归并进度：2023-04-27 20:00:21  >>>>50000000
归并进度：2023-04-27 20:01:24  >>>>60000000
归并进度：2023-04-27 20:02:28  >>>>70000000
归并进度：2023-04-27 20:03:32  >>>>80000000
归并进度：2023-04-27 20:04:36  >>>>90000000
遍历开始：2023-04-27 20:05:38
处理结束：2023-04-27 20:05:43
重复数字：2023-04-27 20:05:49  >>>>{888=2, 666=2}

 

结论：

该方法验证通过

拆分耗时大约1分半

归并耗时大约11分钟

获取重复数字大约6秒

亮点：LineQueue （借鉴自己很早之前做文件行处理时并发任务工具）

 

整体处理数量级是1亿，内存占用理论可控（没输出内存占用情况）

0-1亿数据存储到文本文件内存占用 943 MB (988,888,900 字节)

思考：内存中二路归并排序算法？

思考：BitSet