位图排序算法优化篇-永无止境

我觉得需要……需要速度！”---《Top Gun》

笔者上次写了一篇位图算法实践，介绍了位图算法的概念，编写了一个代码案例并对比了快速排序算法，实践结果性能提高9倍以上，结果还是非常不错的，但正如汤姆克鲁斯在电影《Top Gun》中吐露的心声：人类对于性能的追求是永无止境的！快如剃刀的位图算法是否还有进一步优化的空间呢？

答案是肯定的！

再次审视分析位图算法的代码实现逻辑：就是依次遍历排序数列，以数值为索引给位图数组赋值。静心深思，大脑中很快就蹦出了优化思路：这个遍历赋值的过程是单线程操作，程序开发早就就进入多核时代，完全可以将排序数列进行分治，交给多个线程并发处理。这样肯定能进一步大大提高排序性能！

思路一出，笔者当下大为兴奋，接下来就是继续实践开干了，优化思路也很简单：

1. 创建一个线程池，线程数为两倍电脑CPU个数；
2. 根据排序数据个数以及线程数，计算分区排序个数；
3. 启动线程池，每个线程对所负责数据分区进行排序

代码实现如下：

import common.utils;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import static java.lang.Math.min;

public class BitmapSortEx {
    private static final int MAX = 2000000000;
    private static final int COUNT = 400000000;

    public static void main(String[] args) {
        System.out.println("排序数值最大值:" + MAX);
        System.out.println("排序数值个数:" + COUNT);
        int[] datas = utils.getRandomData(COUNT, MAX);
        final int len = (int) Math.ceil(MAX / 8.0);
      
        long costTime = singleThreadSort(datas, len);
        multiThreadSort(datas, len, costTime);
    }

     // 单线程排序方法，返回运行时间，给多线程排序作为线程池等待超时时长  
    private static long singleThreadSort(int[] datas, int len) {
        byte[] bytes = new byte[len];
        long start = System.currentTimeMillis();
        bitmapSort(datas, bytes);
        long costTime = System.currentTimeMillis() - start;
        System.out.println("单线程位图排序时间:" + costTime + "毫秒");
       
        return costTime;
    }

    // 位图排序法，无法处理重复数据
    private static byte[] bitmapSort(int[] data, final byte[] bytes) {
        for (int i = 0; i < data.length; i++) {
            int j = data[i] >> 3;
            int k = data[i] % 8;
            bytes[j] = utils.setByte(bytes[j], k);
        }
        return bytes;
    }
    // 多线程排序方法  
    private static void multiThreadSort(int[] datas, int len, long costTime) {
        byte[] bytes = new byte[len];
        final int nThreads = Runtime.getRuntime().availableProcessors() * 2;
        System.out.println("多线程排序启动线程数:" + nThreads);
        long start = System.currentTimeMillis();
        ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
        int portion = calcNumPortion(COUNT, nThreads);
        for (int i = 0; i < nThreads; i++) {
            final int from = portion * i;
            final int to = min(portion * (i + 1), COUNT);
            executorService.execute(() -> {
                bitmapSort(datas, from, to, bytes);
            });
        }
        executorService.shutdown();
        try {
           // 等待所有线程结束，完成时间应该小于单线程花费时间
            executorService.awaitTermination(costTime, TimeUnit.MILLISECONDS);
            System.out.println("多线程位图排序时间:" + (System.currentTimeMillis() - start) + "毫秒");
            //utils.printBitData(bytes);
        } catch (InterruptedException e) {//如果被中断了
        }
    }

    private static int calcNumPortion(int data, int parts) {
        int portion = data / parts;
        if ((data % parts) > 0)
            portion++;
        return portion;
    }

    // 位图排序法，无法处理重复数据
    private static byte[] bitmapSort(int[] data, int from, int to, final byte[] bytes) {
        for (int i = from; i < to; i++) {
            int j = data[i] >> 3;
            int k = data[i] % 8;
            bytes[j] = utils.setByte(bytes[j], k);
        }
        return bytes;
    }
}

运行输出如下：

排序数值最大值:2000000000
排序数值个数:400000000
单线程位图排序时间:12099毫秒
多线程排序启动线程数:8
多线程位图排序时间:7463毫秒

可以看出多线程版本运行时间只有单线程的61.7%左右，还是取得很大进步。

程序性能优化之程永无止境，需要用心去做，一路精进。