`
javaG
  • 浏览: 554497 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

fork join例子说明

阅读更多
public static class SelectMaxProblem {
        private final int[] numbers;
        private final int start;
        private final int end;
        public final int size;

        // constructors elided

        public SelectMaxProblem(int[] numbers, int start, int end) {
            this.numbers = numbers;
            this.start = start;
            this.end = end;
            this.size = end - start;
        }

        public int solveSequentially() {
            int max = Integer.MIN_VALUE;
            for (int i=start; i<end; i++) {
                int n = numbers[i];
                if (n > max)
                    max = n;
            }
            return max;
        }

        public SelectMaxProblem subproblem(int subStart, int subEnd) {
            return new SelectMaxProblem(numbers, start + subStart,
                    start + subEnd);
        }

        @Override
        public String toString() {
            return String.format("P{start:%2s, end:%2s}",start,end);
        }
    }

public static class MaxWithFJ extends RecursiveAction {
        private final int threshold;
        private final SelectMaxProblem problem;
        public int result;

        public MaxWithFJ(SelectMaxProblem problem, int threshold) {
            this.problem = problem;
            this.threshold = threshold;
        }

        protected void compute() {
            String pre = problem.toString();
            if (problem.size < threshold) {
                result = problem.solveSequentially();
                print(pre,"return result:"+result);
            }else {
                int midpoint = problem.size / 2;
                SelectMaxProblem leftProblem = problem.subproblem(0, midpoint);
                SelectMaxProblem rightProblem = problem.subproblem(midpoint + 1, problem.size);
                MaxWithFJ left = new MaxWithFJ(leftProblem, threshold);
                MaxWithFJ right = new MaxWithFJ(rightProblem, threshold);
                print(pre,leftProblem + "|" + rightProblem);
                left.fork();
                right.fork();
                print(pre,"fork");
                print(pre,"begin left join");
                left.join();
                print(pre,"after left join.begin rigth join");
                right.join();
                print(pre,"join");
                result = Math.max(left.result, right.result);
            }
        }

        public static void main(String[] args) {
            int size = 40;
            int[] numbers = new int[size];
            for (int i = 0; i < size; i++) {
                numbers[i] = i;
            }
            SelectMaxProblem problem = new SelectMaxProblem(numbers,0,numbers.length);
            int threshold = 10;
            int nThreads = 2;
            MaxWithFJ mfj = new MaxWithFJ(problem, threshold);
            ForkJoinPool fjPool = new ForkJoinPool(nThreads);
            fjPool.invoke(mfj);
            int result = mfj.result;
            print("main",result);
        }

        static void print(String pre,Object object) {
            Thread thread = Thread.currentThread();
            String msg = String.format("Thread[%s] %s > %s", thread.getId(), pre, object);

            System.out.println(msg);
        }
    }


输出结果:
Thread[11] P{start: 0, end:40} > P{start: 0, end:20}|P{start:21, end:40}
Thread[11] P{start: 0, end:40} > fork
Thread[11] P{start: 0, end:40} > begin left join
Thread[12] P{start: 0, end:20} > P{start: 0, end:10}|P{start:11, end:20}
Thread[12] P{start: 0, end:20} > fork
Thread[12] P{start: 0, end:20} > begin left join
Thread[13] P{start:21, end:40} > P{start:21, end:30}|P{start:31, end:40}
Thread[13] P{start:21, end:40} > fork
Thread[13] P{start:21, end:40} > begin left join
Thread[12] P{start: 0, end:10} > P{start: 0, end: 5}|P{start: 6, end:10}
Thread[13] P{start:21, end:30} > return result:29
Thread[12] P{start: 0, end:10} > fork
Thread[13] P{start:21, end:40} > after left join.begin rigth join
Thread[12] P{start: 0, end:10} > begin left join
Thread[12] P{start: 0, end: 5} > return result:4
Thread[13] P{start:31, end:40} > return result:39
Thread[12] P{start: 0, end:10} > after left join.begin rigth join
Thread[13] P{start:21, end:40} > join
Thread[12] P{start: 6, end:10} > return result:9
Thread[13] P{start:11, end:20} > return result:19
Thread[12] P{start: 0, end:10} > join
Thread[12] P{start: 0, end:20} > after left join.begin rigth join
Thread[12] P{start: 0, end:20} > join
Thread[11] P{start: 0, end:40} > after left join.begin rigth join
Thread[11] P{start: 0, end:40} > join
Thread[1] main > 39


说明:
1.RecursiveAction#fork代表用新的线程来执行
2.RecursiveAction#join会让当前线程开始等待.这里和普通的Thread#join的区别是,线程在调用join函数时,会去执行别的任务.可以从输出看到编号12和13的线程,join后再执行子任务.
分享到:
评论

相关推荐

    Fork/Join例子

    标题“Fork/Join例子”暗示我们将探讨一个具体的示例,展示如何使用这个框架来解决问题。通常,这样的例子会涵盖创建自定义的`RecursiveTask`或`RecursiveAction`类,以及如何使用`ForkJoinPool`来执行它们。 描述...

    ForkJoin并发框架入门示例

    ForkJoin并发框架是Java 7引入的一种高效并行计算框架,它基于分而治之(Divide and Conquer)的策略,适用于处理大量可分割的任务。这个框架的核心类是`ForkJoinPool`和`ForkJoinTask`,它们为开发者提供了创建和...

    基于JDK的ForkJoin构建一个简单易用的并发组件1

    虽然对于商品详情页面展示这个特定例子,直接使用线程池可能已经足够,但在处理更大规模、更复杂的问题时,ForkJoin框架能带来显著的性能提升。通过学习和熟练运用ForkJoin,开发者可以构建出更加灵活、高效的并发...

    Stream流式计算、ForkJoin和异步回调.md

    下面是一个简单的ForkJoin框架的应用示例,该示例展示了如何使用ForkJoin框架来计算一组数字的总和: ```java public class ForkJoinDemo extends RecursiveTask&lt;Long&gt; { private Long start; private Long end; ...

    fork/join 实例

    Fork/Join框架是Java并发处理的一个重要工具,它基于工作窃取算法,设计用于高效地执行并行计算任务。这个框架是Java 7引入的,位于`java.util.concurrent.fork/join`包中,目的是简化多核处理器环境下大规模数据...

    Java并发Fork and join

    快速排序是一个经典的适合使用Fork/Join框架的例子。首先创建一个`RecursiveTask`来表示排序任务,任务会检查数组的大小,如果数组元素少于某个阈值,就直接排序(递归结束条件);否则,将数组一分为二,分别创建两...

    JDK7中的ForkJoin模式

    JDK 7 中引入的 Fork/Join 模式是一种基于分治策略的并行编程模型,旨在简化在多核处理器环境下实现高效的并行计算。这一模式的核心思想是将复杂的大任务拆分成一系列小任务,然后将这些小任务并行执行,最后再合并...

    译文:Fork and Join: Java Can Excel at Painless Parallel Programming Too!

    Fork/Join框架是Java SE 7引入的一项重要技术,它使得编写高效、并行的程序变得更加容易。本文将简要回顾Java中的并发编程基础知识,介绍java.util.concurrent包提供的高级并发原语,并深入探讨Fork/Join框架及其在...

    Java通过Fork/Join优化并行计算

    Java的Fork/Join框架是Java 7引入的一个并行计算工具,它是基于分而治之(Divide and Conquer)策略的。该框架旨在简化并行编程,尤其是在多核处理器环境中提高性能。Fork/Join框架的核心类包括`ForkJoinPool`和`...

    java中的forkjoin框架的使用

    否则,任务会被拆分为两个子任务,分别处理数组的一半,然后将两个子任务的结果相加,这就是fork和join的过程。 在实际使用ForkJoinPool时,我们可以通过submit方法提交任务: ```java ForkJoinPool pool = new ...

    Java Fork/Join框架

    Java Fork/Join框架是Java 7引入的一种并行计算模型,设计目的是为了高效地处理大量数据,尤其是在多核处理器环境中。该框架的核心理念是通过将复杂的大任务分解为多个小任务,然后并行执行这些小任务,从而加速计算...

    浅谈Java Fork/Join并行框架

    一个最简单的例子是使用 Fork/Join 框架来求一个数组中的最大/最小值,这个任务就可以拆成很多小任务,大任务就是寻找一个大数组中的最大/最小值,我们可以将一个大数组拆成很多小数组,然后分别求解每个小数组中的...

    常用多线程模板与鱼刺类多线程线程池应用小例子

    下面是一个简单的Fork/Join框架的例子,假设我们要计算一个数组的累加和: ```java import java.util.concurrent.ForkJoinPool; import java.util.concurrent.RecursiveAction; public class SumCalculator ...

    jBPM工作流入门例程

    工作流入门必经的四个简单例子。 vacate主要说明基本使用。...ForkJoin主要说明Fork结点和Join结点的使用。 countersignature主要说明如何持久化和实现较复杂的task node控制, 其中还包括如何monitor你的jBPM。

    ForkAndJoinUtility:实用程序类可轻松使用 java 中的 join 和 fork 功能

    JoinAndForkUtility 可轻松使用 java 7 中的 join 和 fork 功能的实用程序类。 易于使用并提高耗时 for 循环的性能。 更多的是尝试将 fork/join/compute 方法等与业务问题分离。用法如果您必须为大量对象循环耗时的...

    DUBBO小例子

    7. **熔断与容错(Failsafe & Fallback)**:Dubbo提供了熔断和容错机制,如Hystrix、ForkJoin等,以防止服务雪崩,提高系统稳定性。 8. **服务监控(Monitoring)**:Dubbo内置了监控统计功能,可以收集服务调用的...

    Java之Stream

    Fork-Join 框架提供了一些核心类和接口来支持这种模式,主要包括 `ForkJoinPool`(管理任务执行)、`RecursiveAction`(无返回值的任务类型)、`RecursiveTask`(有返回值的任务类型)等。 例如,下面是一个简单...

    Python多进程fork()函数详解

    前面提到的例子仅适用于Unix/Linux环境。对于Windows环境,可以使用`multiprocessing`模块来实现多进程。 ```python from multiprocessing import Process def run_proc(name): print('Run child process %s (%s)...

    SpringMVC+MyBatis整合小例子

    多线程的Fork/Join框架,提升并行计算性能;以及更强大的类型推断等。虽然现在JDK已经有了更高的版本,但在某些场景下,比如兼容旧系统,仍会选择使用JDK1.7。 **Tomcat8** 是一个开源的Servlet容器,实现了Java ...

    活动图示例 活动图例子

    1. **活动图的基本元素**:活动图由几个基本元素构成,包括活动(Activity)、泳道(Swimlane)、决策/合并节点(Decision/Merge Node)、分支(Fork/Join)、初始节点(Initial Node)、终止节点(Final Node)和...

Global site tag (gtag.js) - Google Analytics