在并行流中，分支-合并池（fork-join pool）是用于执行并行任务的线程池。它使用了分治策略，将任务拆分成更小的子任务，并将子任务分配给不同的线程进行并行处理，最后将子任务的结果合并为最终结果。

以下是一个使用分支-合并池的代码示例：

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ParallelStreamExample {
    public static void main(String[] args) {
        // 创建分支-合并池
        ForkJoinPool forkJoinPool = new ForkJoinPool();

        // 创建一个任务
        CustomRecursiveTask task = new CustomRecursiveTask(1, 100);

        // 执行任务并获取结果
        Integer result = forkJoinPool.invoke(task);

        // 输出结果
        System.out.println("Result: " + result);
    }

    // 自定义递归任务
    static class CustomRecursiveTask extends RecursiveTask {
        private int start;
        private int end;

        public CustomRecursiveTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected Integer compute() {
            // 如果任务足够小，直接计算结果
            if (end - start <= 10) {
                int sum = 0;
                for (int i = start; i <= end; i++) {
                    sum += i;
                }
                return sum;
            } else {
                // 将任务拆分成两个子任务
                int mid = (start + end) / 2;
                CustomRecursiveTask leftTask = new CustomRecursiveTask(start, mid);
                CustomRecursiveTask rightTask = new CustomRecursiveTask(mid + 1, end);

                // 并行执行子任务
                leftTask.fork();
                rightTask.fork();

                // 合并子任务的结果
                int leftResult = leftTask.join();
                int rightResult = rightTask.join();

                // 返回最终结果
                return leftResult + rightResult;
            }
        }
    }
}

在上面的示例中，我们创建了一个分支-合并池（ForkJoinPool），然后创建了一个自定义的递归任务（CustomRecursiveTask）。在递归任务的compute()方法中，我们使用了分治策略将任务拆分成更小的子任务，并使用fork()方法并行执行子任务。最后，使用join()方法合并子任务的结果，并返回最终结果。

在主方法中，我们通过调用分支-合并池的invoke()方法执行任务并获取结果。

请注意，分支-合并池在Java 7及以上版本中已经内置，不需要额外导入任何库。