Java中并行执行任务的多种方式

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
 
public class CompletableFutureExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> calculate(10));
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> calculate(20));
 
        CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2);
        combinedFuture.get(); // 等待所有任务完成
 
        System.out.println("Result from future1: " + future1.get());
        System.out.println("Result from future2: " + future2.get());
    }
 
    public static int calculate(int number) {
        // 模拟耗时计算
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return number * 2;
    }
}

import java.util.Arrays;
 
public class ParallelStreamExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
 
        Arrays.stream(numbers)
                .parallel() // 将流转换为并行流
                .mapToObj(number -> calculate(number))
                .forEach(result -> System.out.println("Result: " + result));
    }
 
    public static int calculate(int number) {
        // 模拟耗时计算
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return number * 2;
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
 
public class ExecutorServiceExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
 
        List<Future<Integer>> futures = new ArrayList<>();
 
        for (int i = 0; i < 5; i++) {
            Future<Integer> future = executor.submit(new Task(i));
            futures.add(future);
        }
 
        executor.shutdown(); // 关闭线程池
 
        for (Future<Integer> future : futures) {
            System.out.println("Result: " + future.get());
        }
    }
 
    static class Task implements Callable<Integer> {
        private int number;
 
        public Task(int number) {
            this.number = number;
        }
 
        @Override
        public Integer call() throws Exception {
            // 模拟耗时计算
            Thread.sleep(2000);
            return number * 2;
        }
    }
}
 

import java.util.concurrent.*;
 
public class ForkJoinExample {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
 
        int[] array = {1, 2, 3, 4, 5};
        SumTask task = new SumTask(array, 0, array.length);
 
        int result = forkJoinPool.invoke(task);
        System.out.println("Sum: " + result);
    }
 
    static class SumTask extends RecursiveTask<Integer> {
        private int[] array;
        private int start;
        private int end;
 
        public SumTask(int[] array, int start, int end) {
            this.array = array;
            this.start = start;
            this.end = end;
        }
 
        @Override
        protected Integer compute() {
            if (end - start <= 1) {
                return array[start];
            } else {
                int mid = start + (end - start) / 2;
                SumTask leftTask = new SumTask(array, start, mid);
                SumTask rightTask = new SumTask(array, mid, end);
                leftTask.fork();
                rightTask.fork();
                return leftTask.join() + rightTask.join();
            }
        }
    }
}