Java并行處理的實現(xiàn)

更新時間：2021年07月14日 11:54:26 作者：張云飛Vir

并行計算一般是指許多指令得以同時進行的計算模式。本文主要介紹了Java并行處理的實現(xiàn)，具有一定的參考價值，感興趣的小伙伴們可以參考一下

1. 背景

本文是一個短文章，介紹Java 中的并行處理。
說明：10多分鐘讀完的文章我稱之為短文章，適合快速閱讀。

2.知識

并行計算（parallel computing）一般是指許多指令得以同時進行的計算模式。在同時進行的前提下，可以將計算的過程分解成小部分，之后以并發(fā)方式來加以解決。

也就是分解為幾個過程：

1、將一個大任務(wù)拆分成多個子任務(wù)，子任務(wù)還可以繼續(xù)拆分。
2、各個子任務(wù)同時進行運算執(zhí)行。
3、在執(zhí)行完畢后，可能會有個 " 歸納 " 的任務(wù)，比如求和，求平均等。

再簡化一點的理解就是: 先拆分 --> 在同時進行計算 --> 最后“歸納”
為什么要“并行”，優(yōu)點呢？

1、為了獲得 “節(jié)省時間”，“快”。適合用于大規(guī)模運算的場景。從理論上講，在 n 個并行處理的執(zhí)行速度可能會是在單一處理機上執(zhí)行的速度的 n 倍。
2、以前的計算機是單核的，現(xiàn)代的計算機Cpu都是多核的，服務(wù)器甚至都是多Cpu的，并行計算可以充分利用硬件的性能。

3. Java 中的并行處理

JDK 8 新增的Stream API（java.util.stream）將生成環(huán)境的函數(shù)式編程引入了Java庫中，可以方便開發(fā)者能夠?qū)懗龈佑行?、更加簡潔的代碼。

steam 的另一個價值是創(chuàng)造性地支持并行處理（parallel processing）。示例：

final Collection< Task > tasks = Arrays.asList(
    new Task( Status.OPEN, 5 ),
    new Task( Status.OPEN, 13 ),
    new Task( Status.CLOSED, 8 ) 
);

// 并行執(zhí)行多個任務(wù)，并 求和
final double totalPoints = tasks
   .stream()
   .parallel()
   .map( task -> task.getPoints() ) // or map( Task::getPoints ) 
   .reduce( 0, Integer::sum );
 
System.out.println( "Total points (all tasks): " + totalPoints );

對于上面的tasks集合，上面的代碼計算所有任務(wù)的點數(shù)之和。
它使用 parallel 方法并行處理所有的task，并使用 reduce 方法計算最終的結(jié)果。

4. 擴展

線程池方式實現(xiàn)并行處理

jdk1.5引入了并發(fā)包，其中包括了ThreadPoolExecutor，相關(guān)代碼如下：

public class ExecutorServiceTest {
 
    public static final int THRESHOLD = 10_000;
    public static long[] numbers;
 
    public static void main(String[] args) throws Exception {
        numbers = LongStream.rangeClosed(1, 10_000_000).toArray();
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);
        CompletionService<Long> completionService = new ExecutorCompletionService<Long>(executor);
        int taskSize = (int) (numbers.length / THRESHOLD);
        for (int i = 1; i <= taskSize; i++) {
            final int key = i;
            completionService.submit(new Callable<Long>() {
 
                @Override
                public Long call() throws Exception {
                    return sum((key - 1) * THRESHOLD, key * THRESHOLD);
                }
            });
        }
        long sumValue = 0;
        for (int i = 0; i < taskSize; i++) {
            sumValue += completionService.take().get();
        }
        // 所有任務(wù)已經(jīng)完成,關(guān)閉線程池
        System.out.println("sumValue = " + sumValue);
        executor.shutdown();
    }
 
    private static long sum(int start, int end) {
        long sum = 0;
        for (int i = start; i < end; i++) {
            sum += numbers[i];
        }
        return sum;
    }
}

使用 fork/join框架

分支/合并框架的目的是以遞歸的方式將可以并行的認為拆分成更小的任務(wù)，然后將每個子任務(wù)的結(jié)果合并起來生成整體結(jié)果；相關(guān)代碼如下：

public class ForkJoinTest extends java.util.concurrent.RecursiveTask<Long> {
    
    private static final long serialVersionUID = 1L;
    private final long[] numbers;
    private final int start;
    private final int end;
    public static final long THRESHOLD = 10_000;
 
    public ForkJoinTest(long[] numbers) {
        this(numbers, 0, numbers.length);
    }
 
    private ForkJoinTest(long[] numbers, int start, int end) {
        this.numbers = numbers;
        this.start = start;
        this.end = end;
    }
 
    @Override
    protected Long compute() {
        int length = end - start;
        if (length <= THRESHOLD) {
            return computeSequentially();
        }
        ForkJoinTest leftTask = new ForkJoinTest(numbers, start, start + length / 2);
        leftTask.fork();
        ForkJoinTest rightTask = new ForkJoinTest(numbers, start + length / 2, end);
        Long rightResult = rightTask.compute();
        // 注：join方法會阻塞，因此有必要在兩個子任務(wù)的計算都開始之后才執(zhí)行join方法
        Long leftResult = leftTask.join();
        return leftResult + rightResult;
    }
 
    private long computeSequentially() {
        long sum = 0;
        for (int i = start; i < end; i++) {
            sum += numbers[i];
        }
        return sum;
    }
 
    public static void main(String[] args) {
        System.out.println(forkJoinSum(10_000_000));
    }
 
    public static long forkJoinSum(long n) {
        long[] numbers = LongStream.rangeClosed(1, n).toArray();
        ForkJoinTask<Long> task = new ForkJoinTest(numbers);
        return new ForkJoinPool().invoke(task);
    }
}

上面的代碼實現(xiàn)了遞歸方式拆分子任務(wù)，并放入到線程池中執(zhí)行。