任务调度并行算法的Java简单实现

今天下午抽空写了下并行调度算法的Java版本，是想把这个思路先实现了，后面改写Python版作为参考，调试这个版本之后，再来写Python版，发现差别还不小。

Java版本的目前支持动态赋值，目前的元素个数是10个，可以根据情况修改，并行度是4，可以根据情况修改。

import java.util.Random;
import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
    new Test().test();
       // int[] array ={96,59,55,34,22,11,7,5,3,2};
       // new Test().getMaxIndex(array);
    }

    public void test(){
        System.out.println("test");

        int ARRAY_SIZE = 10;
        int test_array[] = new int[ARRAY_SIZE];
        for (int i = 0; i < ARRAY_SIZE; i++) {
            test_array[i] = new Random().nextInt(100);
        }

        Arrays.sort(test_array);

        for (int i = 0; i < ARRAY_SIZE; i++) {
            System.out.println(test_array[i]);
        }

        int GRP_NO = 4;
        int array_group[][] = new int[GRP_NO][ARRAY_SIZE];
        int array_sum_group [] = new int[GRP_NO];
        for (int i = 0; i < GRP_NO; i++) {
            array_group[i][0] = test_array[ARRAY_SIZE - i - 1];
            array_sum_group[i] = test_array[ARRAY_SIZE - i - 1];
            System.out.println("init value :"+array_sum_group[i]);
        }


        int min_grp_no = 0;
        int max_index = 0;


        for (int i = ARRAY_SIZE-GRP_NO-1 ; i >= 0; i--) {
            //get min array group index
            System.out.println("new value:"+test_array[i]);
            min_grp_no = getMinGrpNo(array_sum_group);
            max_index = getMaxIndex(array_group[min_grp_no]);
            array_group[min_grp_no][max_index+1] = test_array[i];
            array_sum_group[min_grp_no] +=  test_array[i];
            System.out.println(array_group[min_grp_no][max_index+1]+","+array_group[min_grp_no][max_index]+","+array_sum_group[min_grp_no]);
        }

    System.out.println(array_group);
    }
    public  int getMinGrpNo(int[] array) {
        int temp_value = 0;
        int min_index = 0;
        if(array.length>1) {
              temp_value = array[0];
              for (int i = 1; i < array.length; i++) {
                   if (temp_value > array[i]) {
                      temp_value = array[i];
                      min_index = i;
                    }
                  }
            }
        System.out.println("getMinGrpNo:"+min_index+" value:"+temp_value);
        return min_index;
    }

    public  int getMaxIndex(int[] array) {
        int temp_value = 0;
        int max_index = 0;
        if(array.length>1) {
            temp_value = array[0];
            for (int i = 1; i < array.length; i++) {
                if(array[i] != 0) {
                    if (temp_value > array[i]) {
                        temp_value = array[i];
                        max_index = i;
                    }
                }
            }
        }
        System.out.println("getMaxIndex:"+max_index+" value:"+temp_value);
        return max_index;
    }

}

程序的执行结果如下，整体的思路是生成随机数的数组，然后对数组排序，然后对数组做数据处理，每次添加新元素都需要对每组累计值做一个排序，累计值最小的可以添加新的元素，直至元素被添加完。

所以自己在逻辑的部分写了两个函数来单独处理：

一个是得到累计值最小的数组，得到数组的下标

另外一个是查找数组中元素的最大下标，比如数组有3个元素，那么最大下标就是2（数组从0开始）

test
18
28
31
33
41
57
59
59
79
86
init value :86
init value :79
init value :59
init value :59
new value:57
getMinGrpNo:2 value:59
getMaxIndex:0 value:59
57,59,116
new value:41
getMinGrpNo:3 value:59
getMaxIndex:0 value:59
41,59,100
new value:33
getMinGrpNo:1 value:79
getMaxIndex:0 value:79
33,79,112
new value:31
getMinGrpNo:0 value:86
getMaxIndex:0 value:86
31,86,117
new value:28
getMinGrpNo:3 value:100
getMaxIndex:1 value:41
28,41,128
new value:18
getMinGrpNo:1 value:112
getMaxIndex:1 value:33
18,33,130

当然上面的实现，如果拿10个元素来看，好像意义不大，但是如果是100个，200个这种场景，你会明显感觉到效果了。