JDK 7 中的 Fork/Join 模式 轻松实现多核时代的并行计算

最新推荐文章于 2022-07-12 09:49:26 发布
最新推荐文章于 2022-07-12 09:49:26 发布
阅读量1.4k 收藏 1
点赞数
文章标签： jdk 任务 pivot thread import concurrency

JDK 7 中的 Fork/Join 模式

轻松实现多核时代的并行计算

http://www.ibm.com/developerworks/cn/java/j-lo-forkjoin/index.html

2007 年 8 月 23 日

随着多核时代的来临，软件开发人员不得不开始关注并行编程领域。而 JDK 7 中将会加入的 Fork/Join 模式是处理并行编程的一个经典的方法。虽然不能解决所有的问题，但是在它的适用范围之内，能够轻松的利用多个 CPU 提供的计算资源来协作完成一个复杂的计算任务。通过利用 Fork/Join 模式，我们能够更加顺畅的过渡到多核的时代。本文将介绍使用 JDK 7 中 Fork/Join 模式的方法和其他相关改进。阅读本文之后，读者将能够独立地在软件开发中使用 Fork/Join 模式来改进程序的性能。

介绍

随 着多核芯片逐渐成为主流，大多数软件开发人员不可避免地需要了解并行编程的知识。而同时，主流程序语言正在将越来越多的并行特性合并到标准库或者语言本身 之中。我们可以看到，JDK 在这方面同样走在潮流的前方。在 JDK 标准版 5 中，由 Doug Lea 提供的并行框架成为了标准库的一部分（JSR-166）。随后，在 JDK 6 中，一些新的并行特性，例如并行 collection 框架，合并到了标准库中（JSR-166x）。直到今天，尽管 Java SE 7 还没有正式发布，一些并行相关的新特性已经出现在 JSR-166y 中：

  1. Fork/Join 模式；
  2. TransferQueue，它继承自 BlockingQueue 并能在队列满时阻塞“生产者”；
  3. ArrayTasks/ListTasks，用于并行执行某些数组/列表相关任务的类；
  4. IntTasks/LongTasks/DoubleTasks，用于并行处理数字类型数组的工具类，提供了排序、查找、求和、求最小值、求最大值等功能；

其 中，对 Fork/Join 模式的支持可能是对开发并行软件来说最通用的新特性。在 JSR-166y 中，Doug Lea 实现 ArrayTasks/ListTasks/IntTasks/LongTasks/DoubleTasks 时就大量的用到了 Fork/Join 模式。读者还需要注意一点，因为 JDK 7 还没有正式发布，因此本文涉及到的功能和发布版本有可能不一样。

Fork/Join 模式有自己的适用范围。如果一个应用能被分解成多个子任务，并且组合多个子任务的结果就能够获得最终的答案，那么这个应用就适合用 Fork/Join 模式来解决。图 1 给出了一个 Fork/Join 模式的示意图，位于图上部的 Task 依赖于位于其下的 Task 的执行，只有当所有的子任务都完成之后，调用者才能获得 Task 0 的返回结果。


图 1. Fork/Join 模式示意图

可 以说，Fork/Join 模式能够解决很多种类的并行问题。通过使用 Doug Lea 提供的 Fork/Join 框架，软件开发人员只需要关注任务的划分和中间结果的组合就能充分利用并行平台的优良性能。其他和并行相关的诸多难于处理的问题，例如负载平衡、同步等，都可以由框架采用统一的方式解决。这样，我们就能够轻松地获得并行的好处而避免了并行编程的困难且容易出错的缺点。

使用 Fork/Join 模式

在开始尝试 Fork/Join 模式之前，我们需要从 Doug Lea 主持的 Concurrency JSR-166 Interest Site 上下载 JSR-166y 的源代码，并且我们还需要安装最新版本的 JDK 6（下载网址请参阅 参考资源）。Fork/Join 模式的使用方式非常直观。首先，我们需要编写一个 ForkJoinTask 来完成子任务的分割、中间结果的合并等工作。随后，我们将这个 ForkJoinTask 交给 ForkJoinPool 来完成应用的执行。

通 常我们并不直接继承 ForkJoinTask，它包含了太多的抽象方法。针对特定的问题，我们可以选择 ForkJoinTask 的不同子类来完成任务。RecursiveAction 是 ForkJoinTask 的一个子类，它代表了一类最简单的 ForkJoinTask：不需要返回值，当子任务都执行完毕之后，不需要进行中间结果的组合。如果我们从 RecursiveAction 开始继承，那么我们只需要重载 protected void compute() 方法。下面，我们来看看怎么为快速排序算法建立一个 ForkJoinTask 的子类：


清单 1. ForkJoinTask 的子类

class SortTask extends RecursiveAction {
    final long[] array;
    final int lo;
    final int hi;
    private int THRESHOLD = 30;

      
      
       
        
      
      
    public SortTask(long[] array) {
        this.array = array;
        this.lo = 0;
        this.hi = array.length - 1;
    }

      
      
       
        
      
      
    public SortTask(long[] array, int lo, int hi) {
        this.array = array;
        this.lo = lo;
        this.hi = hi;
    }

      
      
       
        
      
      
    protected void compute() {
        if (hi - lo < THRESHOLD)
            sequentiallySort(array, lo, hi);
        else {
            int pivot = partition(array, lo, hi);
            coInvoke(new SortTask(array, lo, pivot - 1), new SortTask(array,
                pivot + 1, hi));
        }
    }

      
      
       
        
      
      
    private int partition(long[] array, int lo, int hi) {
        long x = array[hi];
        int i = lo - 1;
        for (int j = lo; j < hi; j++) {
            if (array[j] <= x) {
                i++;
                swap(array, i, j);
            }
        }
        swap(array, i + 1, hi);
        return i + 1;
    }

      
      
       
        
      
      
    private void swap(long[] array, int i, int j) {
        if (i != j) {
            long temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }

      
      
       
        
      
      
    private void sequentiallySort(long[] array, int lo, int hi) {
        Arrays.sort(array, lo, hi + 1);
    }
}

 

在 清单 1 中，SortTask 首先通过 partition() 方法将数组分成两个部分。随后，两个子任务将被生成并分别排序数组的两个部分。当子任务足够小时，再将其分割为更小的任务反而引起性能的降低。因此，这里我们使用一个 THRESHOLD，限定在子任务规模较小时，使用直接排序，而不是再将其分割成为更小的任务。其中，我们用到了 RecursiveAction 提供的方法 coInvoke()。它表示：启动所有的任务，并在所有任务都正常结束后返回。如果其中一个任务出现异常，则其它所有的任务都取消。coInvoke() 的参数还可以是任务的数组。

现在剩下的工作就是将 SortTask 提交到 ForkJoinPool 了。ForkJoinPool() 默认建立具有与 CPU 可使用线程数相等线程个数的线程池。我们在一个 JUnit 的 test 方法中将 SortTask 提交给一个新建的 ForkJoinPool：


清单 2. 新建的 ForkJoinPool

@Test
public void testSort() throws Exception {
    ForkJoinTask sort = new SortTask(array);
    ForkJoinPool fjpool = new ForkJoinPool();
    fjpool.submit(sort);
    fjpool.shutdown();

      
      
       
        
      
      
    fjpool.awaitTermination(30, TimeUnit.SECONDS);

      
      
       
        
      
      
    assertTrue(checkSorted(array));
}

 

在上面的代码中，我们用到了 ForkJoinPool 提供的如下函数：

  1. submit()：将 ForkJoinTask 类的对象提交给 ForkJoinPool，ForkJoinPool 将立刻开始执行 ForkJoinTask。
  2. shutdown()：执行此方法之后，ForkJoinPool 不再接受新的任务，但是已经提交的任务可以继续执行。如果希望立刻停止所有的任务，可以尝试 shutdownNow() 方法。
  3. awaitTermination()：阻塞当前线程直到 ForkJoinPool 中所有的任务都执行结束。

并行快速排序的完整代码如下所示：


清单 3. 并行快速排序的完整代码

package tests;

      
      
       
        
      
      
import static org.junit.Assert.*;

      
      
       
        
      
      
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.TimeUnit;

      
      
       
        
      
      
import jsr166y.forkjoin.ForkJoinPool;
import jsr166y.forkjoin.ForkJoinTask;
import jsr166y.forkjoin.RecursiveAction;

      
      
       
        
      
      
import org.junit.Before;
import org.junit.Test;

      
      
       
        
      
      
class SortTask extends RecursiveAction {
    final long[] array;
    final int lo;
    final int hi;
    private int THRESHOLD = 0; //For demo only

      
      
       
        
      
      
    public SortTask(long[] array) {
        this.array = array;
        this.lo = 0;
        this.hi = array.length - 1;
    }

      
      
       
        
      
      
    public SortTask(long[] array, int lo, int hi) {
        this.array = array;
        this.lo = lo;
        this.hi = hi;
    }

      
      
       
        
      
      
    protected void compute() {
        if (hi - lo < THRESHOLD)
            sequentiallySort(array, lo, hi);
        else {
            int pivot = partition(array, lo, hi);
            System.out.println("/npivot = " + pivot + ", low = " + lo + ", high = " + hi);
                       System.out.println("array" + Arrays.toString(array));
            coInvoke(new SortTask(array, lo, pivot - 1), new SortTask(array,
                    pivot + 1, hi));
        }
    }

      
      
       
        
      
      
    private int partition(long[] array, int lo, int hi) {
        long x = array[hi];
        int i = lo - 1;
        for (int j = lo; j < hi; j++) {
            if (array[j] <= x) {
                i++;
                swap(array, i, j);
            }
        }
        swap(array, i + 1, hi);
        return i + 1;
    }

      
      
       
        
      
      
    private void swap(long[] array, int i, int j) {
        if (i != j) {
            long temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }

      
      
       
        
      
      
    private void sequentiallySort(long[] array, int lo, int hi) {
        Arrays.sort(array, lo, hi + 1);
    }
}

      
      
       
        
      
      
public class TestForkJoinSimple {
    private static final int NARRAY = 16; //For demo only
    long[] array = new long[NARRAY];
    Random rand = new Random();

      
      
       
        
      
      
    @Before
    public void setUp() {
        for (int i = 0; i < array.length; i++) {
            array[i] = rand.nextLong()%100; //For demo only
        }
        System.out.println("Initial Array: " + Arrays.toString(array));
    }

      
      
       
        
      
      
    @Test
    public void testSort() throws Exception {
        ForkJoinTask sort = new SortTask(array);
        ForkJoinPool fjpool = new ForkJoinPool();
        fjpool.submit(sort);
        fjpool.shutdown();

      
      
       
        
      
      
        fjpool.awaitTermination(30, TimeUnit.SECONDS);

      
      
       
        
      
      
        assertTrue(checkSorted(array));
    }

      
      
       
        
      
      
    boolean checkSorted(long[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            if (a[i] > (a[i + 1])) {
                return false;
            }
        }
        return true;
    }
}

 

运行以上代码，我们可以得到以下结果：

Initial Array: [46, -12, 74, -67, 76, -13, -91, -96]

      
      
       
        
      
      
pivot = 0, low = 0, high = 7
array[-96, -12, 74, -67, 76, -13, -91, 46]

      
      
       
        
      
      
pivot = 5, low = 1, high = 7
array[-96, -12, -67, -13, -91, 46, 76, 74]

      
      
       
        
      
      
pivot = 1, low = 1, high = 4
array[-96, -91, -67, -13, -12, 46, 74, 76]

      
      
       
        
      
      
pivot = 4, low = 2, high = 4
array[-96, -91, -67, -13, -12, 46, 74, 76]

      
      
       
        
      
      
pivot = 3, low = 2, high = 3
array[-96, -91, -67, -13, -12, 46, 74, 76]

      
      
       
        
      
      
pivot = 2, low = 2, high = 2
array[-96, -91, -67, -13, -12, 46, 74, 76]

      
      
       
        
      
      
pivot = 6, low = 6, high = 7
array[-96, -91, -67, -13, -12, 46, 74, 76]

      
      
       
        
      
      
pivot = 7, low = 7, high = 7
array[-96, -91, -67, -13, -12, 46, 74, 76]

 

Fork/Join 模式高级特性

使用 RecursiveTask

除了 RecursiveAction，Fork/Join 框架还提供了其他 ForkJoinTask 子类：带有返回值的 RecursiveTask，使用 finish() 方法显式中止的 AsyncAction 和 LinkedAsyncAction，以及可使用 TaskBarrier 为每个任务设置不同中止条件的 CyclicAction。

从 RecursiveTask 继承的子类同样需要重载 protected void compute() 方法。与 RecursiveAction 稍有不同的是，它可使用泛型指定一个返回值的类型。下面，我们来看看如何使用 RecursiveTask 的子类。


清单 4. RecursiveTask 的子类

class Fibonacci extends RecursiveTask<Integer> {
    final int n;

      
      
       
        
      
      
    Fibonacci(int n) {
        this.n = n;
    }

      
      
       
        
      
      
    private int compute(int small) {
        final int[] results = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
        return results[small];
    }

      
      
       
        
      
      
    public Integer compute() {
        if (n <= 10) {
            return compute(n);
        }
        Fibonacci f1 = new Fibonacci(n - 1);
        Fibonacci f2 = new Fibonacci(n - 2);
        f1.fork();
        f2.fork();
        return f1.join() + f2.join();
    }
}

 

在 清单 4 中， Fibonacci 的返回值为 Integer 类型。其 compute() 函数首先建立两个子任务，启动子任务执行，阻塞以等待子任务的结果返回，相加后得到最终结果。同样，当子任务足够小时，通过查表得到其结果，以减小因过多地分割任务引起的性能降低。其中，我们用到了 RecursiveTask 提供的方法 fork() 和 join()。它们分别表示：子任务的异步执行和阻塞等待结果完成。

现在剩下的工作就是将 Fibonacci 提交到 ForkJoinPool 了，我们在一个 JUnit 的 test 方法中作了如下处理：


清单 5. 将 Fibonacci 提交到 ForkJoinPool

@Test
public void testFibonacci() throws InterruptedException, ExecutionException {
    ForkJoinTask<Integer> fjt = new Fibonacci(45);
    ForkJoinPool fjpool = new ForkJoinPool();
    Future<Integer> result = fjpool.submit(fjt);

      
      
       
        
      
      
    // do something
    System.out.println(result.get());
}

 

使用 CyclicAction 来处理循环任务

CyclicAction 的用法稍微复杂一些。如果一个复杂任务需要几个线程协作完成，并且线程之间需要在某个点等待所有其他线程到达，那么我们就能方便的用 CyclicAction 和 TaskBarrier 来完成。图 2 描述了使用 CyclicAction 和 TaskBarrier 的一个典型场景。

图 2. 使用 CyclicAction 和 TaskBarrier 执行多线程任务

继承自 CyclicAction 的子类需要 TaskBarrier 为每个任务设置不同的中止条件。从 CyclicAction 继承的子类需要重载 protected void compute() 方法，定义在 barrier 的每个步骤需要执行的动作。compute() 方法将被反复执行直到 barrier 的 isTerminated() 方法返回 True。TaskBarrier 的行为类似于 CyclicBarrier。下面，我们来看看如何使用 CyclicAction 的子类。


清单 6. 使用 CyclicAction 的子类

class ConcurrentPrint extends RecursiveAction {
    protected void compute() {
        TaskBarrier b = new TaskBarrier() {
            protected boolean terminate(int cycle, int registeredParties) {
                System.out.println("Cycle is " + cycle + ";"
                        + registeredParties + " parties");
                return cycle >= 10;
            }
        };
        int n = 3;
        CyclicAction[] actions = new CyclicAction[n];
        for (int i = 0; i < n; ++i) {
            final int index = i;
            actions[i] = new CyclicAction(b) {
                protected void compute() {
                    System.out.println("I'm working " + getCycle() + " "
                            + index);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
        }
        for (int i = 0; i < n; ++i)
            actions[i].fork();
        for (int i = 0; i < n; ++i)
            actions[i].join();
    }
}

 

在 清单 6 中，CyclicAction[] 数组建立了三个任务，打印各自的工作次数和序号。而在 b.terminate() 方法中，我们设置的中止条件表示重复 10 次计算后中止。现在剩下的工作就是将 ConcurrentPrint 提交到 ForkJoinPool 了。我们可以在 ForkJoinPool 的构造函数中指定需要的线程数目，例如 ForkJoinPool(4) 就表明线程池包含 4 个线程。我们在一个 JUnit 的 test 方法中运行 ConcurrentPrint 的这个循环任务：


清单 7. 运行 ConcurrentPrint 循环任务

@Test
public void testBarrier () throws InterruptedException, ExecutionException {
    ForkJoinTask fjt = new ConcurrentPrint();
    ForkJoinPool fjpool = new ForkJoinPool(4);
    fjpool.submit(fjt);
    fjpool.shutdown();
}

 

RecursiveTask 和 CyclicAction 两个例子的完整代码如下所示：


清单 8. RecursiveTask 和 CyclicAction 两个例子的完整代码

package tests;

      
      
       
        
      
      
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

      
      
       
        
      
      
import jsr166y.forkjoin.CyclicAction;
import jsr166y.forkjoin.ForkJoinPool;
import jsr166y.forkjoin.ForkJoinTask;
import jsr166y.forkjoin.RecursiveAction;
import jsr166y.forkjoin.RecursiveTask;
import jsr166y.forkjoin.TaskBarrier;

      
      
       
        
      
      
import org.junit.Test;

      
      
       
        
      
      
class Fibonacci extends RecursiveTask<Integer> {
    final int n;

      
      
       
        
      
      
    Fibonacci(int n) {
        this.n = n;
    }

      
      
       
        
      
      
    private int compute(int small) {
        final int[] results = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
        return results[small];
    }

      
      
       
        
      
      
    public Integer compute() {
        if (n <= 10) {
            return compute(n);
        }
        Fibonacci f1 = new Fibonacci(n - 1);
        Fibonacci f2 = new Fibonacci(n - 2);
        System.out.println("fork new thread for " + (n - 1));
        f1.fork();
        System.out.println("fork new thread for " + (n - 2));
        f2.fork();
        return f1.join() + f2.join();
    }
}

      
      
       
        
      
      
class ConcurrentPrint extends RecursiveAction {
    protected void compute() {
        TaskBarrier b = new TaskBarrier() {
            protected boolean terminate(int cycle, int registeredParties) {
                System.out.println("Cycle is " + cycle + ";"
                        + registeredParties + " parties");
                return cycle >= 10;
            }
        };
        int n = 3;
        CyclicAction[] actions = new CyclicAction[n];
        for (int i = 0; i < n; ++i) {
            final int index = i;
            actions[i] = new CyclicAction(b) {
                protected void compute() {
                    System.out.println("I'm working " + getCycle() + " "
                            + index);
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
        }
        for (int i = 0; i < n; ++i)
            actions[i].fork();
        for (int i = 0; i < n; ++i)
            actions[i].join();
    }
}

      
      
       
        
      
      
public class TestForkJoin {
    @Test
    public void testBarrier () throws InterruptedException, ExecutionException {
               System.out.println("/ntesting Task Barrier ...");
        ForkJoinTask fjt = new ConcurrentPrint();
        ForkJoinPool fjpool = new ForkJoinPool(4);
        fjpool.submit(fjt);
        fjpool.shutdown();
    }

      
      
       
        
      
      
    @Test
    public void testFibonacci () throws InterruptedException, ExecutionException {
        System.out.println("/ntesting Fibonacci ...");
               final int num = 14; //For demo only
        ForkJoinTask<Integer> fjt = new Fibonacci(num);
        ForkJoinPool fjpool = new ForkJoinPool();
        Future<Integer> result = fjpool.submit(fjt);

      
      
       
        
      
      
        // do something
        System.out.println("Fibonacci(" + num + ") = " + result.get());
    }
}

 

运行以上代码，我们可以得到以下结果：

testing Task Barrier ...
I'm working 0 2
I'm working 0 0
I'm working 0 1
Cycle is 0; 3 parties
I'm working 1 2
I'm working 1 0
I'm working 1 1
Cycle is 1; 3 parties
I'm working 2 0
I'm working 2 1
I'm working 2 2
Cycle is 2; 3 parties
I'm working 3 0
I'm working 3 2
I'm working 3 1
Cycle is 3; 3 parties
I'm working 4 2
I'm working 4 0
I'm working 4 1
Cycle is 4; 3 parties
I'm working 5 1
I'm working 5 0
I'm working 5 2
Cycle is 5; 3 parties
I'm working 6 0
I'm working 6 2
I'm working 6 1
Cycle is 6; 3 parties
I'm working 7 2
I'm working 7 0
I'm working 7 1
Cycle is 7; 3 parties
I'm working 8 1
I'm working 8 0
I'm working 8 2
Cycle is 8; 3 parties
I'm working 9 0
I'm working 9 2

      
      
       
        
      
      
testing Fibonacci ...
fork new thread for 13
fork new thread for 12
fork new thread for 11
fork new thread for 10
fork new thread for 12
fork new thread for 11
fork new thread for 10
fork new thread for 9
fork new thread for 10
fork new thread for 9
fork new thread for 11
fork new thread for 10
fork new thread for 10
fork new thread for 9
Fibonacci(14) = 610

结论

从 以上的例子中可以看到，通过使用 Fork/Join 模式，软件开发人员能够方便地利用多核平台的计算能力。尽管还没有做到对软件开发人员完全透明，Fork/Join 模式已经极大地简化了编写并发程序的琐碎工作。对于符合 Fork/Join 模式的应用，软件开发人员不再需要处理各种并行相关事务，例如同步、通信等，以难以调试而闻名的死锁和 data race 等错误也就不会出现，提升了思考问题的层次。你可以把 Fork/Join 模式看作并行版本的 Divide and Conquer 策略，仅仅关注如何划分任务和组合中间结果，将剩下的事情丢给 Fork/Join 框架。

在实际工作中利用 Fork/Join 模式，可以充分享受多核平台为应用带来的免费午餐。

参考资料

学习

 

 

 

dongtg
关注
【项目实战】并发编程之Fork/Join模式 - 处理并行编程的经典方法入门介绍
本本本添哥
04-13 455
当涉及到解决可以分解为较小子问题的问题时，Fork/Join模式是一种并行计算模式与并行编程模型。
Java fork/join —— 拆分任务并行执行
superSubfn
12-10 1477
从JDK1.7开始，Java提供ForkJoin框架用于并行执行任务，它的思想就是讲一个大任务分割成若干小任务，最终汇总每个小任务的结果得到这个大任务的结果。作为一个并发框架在jdk7的时候就加入到了我们的java并发包java.util.concurrent中，并且在java 8 的lambda并行流中充当着底层框架的角色。
JDK7并行计算框架介绍一 Fork/Join概述（官方原版-英文）
weixin_34186128的博客
02-21 91
Fork/Join New in the Java SE 7 release, the fork/join framework is an implementation of the ExecutorService interface that helps you take advantage of multiple processors. It is designed for work tha...
java jdk7 并行计算框架 fork/join
u012760183的专栏
04-26 792
原文地址  ： http://www.iteye.com/topic/643724   //简单的例子 http://www.infoq.com/cn/articles/fork-join-introduction/  //对源码简要的分析。。 其中还涉及到 工作窃取算法 ：   假如我们需要做一个比较大的任务，我们可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争
ForkJoin多核并行框架总结
SumResort_LChaowei的博客
05-28 625
1.阿姆达尔定律定义 一个程序（或者一个算法）可以按照是否可以被并行化分为下面两个部分： 可以被并行化的部分 不可以被并行化的部分 阿姆达尔定律给出了任务在固定负载的情况下，随着系统资源的提升，执行速度的理论上限。以计算机科学家Gene Amdahl命名。p为串行程序所在比例 ·  ·  Slatency(s)=1(1−p)+ps ·  ·  2. Fork Join
jdk7 并行计算框架Fork/Join
chenglinhust的专栏
01-09 912
jdk7 并行计算框架Fork/Join 故名思义，拆分fork+合并join。jdk1.7整合Fork/Join，性能上有大大提升。 思想:充分利用多核CPU把计算拆分成多个子任务，并行计算，提高CPU利用率大大减少运算时间。有点像，MapReduce思路感觉大致一样。 jdk7中已经提供了最简洁的接口，让你不需要太多时间关心并行时线程的通信，死锁问题，线程同步，下
JDK1.7新特性（二）Fork/Join框架demo
caicongyang
04-18 2634
JDK1.7新特性（二）Fork/Join框架demo
JDK7的Fork/Join模式：并行编程新利器
"本文主要介绍了JDK7中的Fork/Join模式，它是并行编程的一种经典方法，尤其适用于多核处理器环境。Fork/Join模式允许开发者将复杂问题拆分成可并行处理的小任务，从而有效利用多核CPU的计算能力。在JDK7中，这一模式...
JDK7中的ForkJoin模式
04-15
JDK 7 中引入的 Fork/Join 模式是一种基于分治策略的并行编程模型，旨在简化在多核处理器环境下实现高效的并行计算。这一模式的核心思想是将复杂的大任务拆分成一系列小任务，然后将这些小任务并行执行，最后再合并...
java Fork Join框架及使用
01-07
Fork/Join框架是Java7引入的一种用于并行任务执行的框架，它允许将复杂任务拆分成多个子任务，并行执行，然后通过join操作将结果聚合。Fork/Join框架特别适合处理可以递归拆分的计算密集型任务，比如大数据集的搜索...
java中Fork-Join框架
zsj777的专栏
07-12 227
一、使用场景 大任务拆解成多个子任务，子任务还可以继续拆解成更小的子任务，最后将这些最小的子任务用多个线程并行执行，然后合并执行结果，例如，对超过1000万个元素的数组进行排序。需求：有一个大数据量的用户List，根据其部门id，设置部门名称。ForkJoin模型利用了分治算法的思想，将大任务不断拆解，多线程执行，最后合并结果。它的本质是一个线程池。每一个工作线程维护一个本地的双端队列用来存放任务。线程在运行的过程中产生新的任务（通常是因为调用了 fork()）时，会放入工作队列的队尾，并且
【多线程】fork-join并行计算框架
weixin_39362168的博客
06-23 313
什么是fork-join计算框架 可以将一个大的任务拆分成多个子任务进行并行处理，最后将子任务结果合并成最后的计算结果，并进行输出。 什么是分而治之？ 规模为N的问题，N<阈值，直接解决，N>阈值，将N分解为K个小规模子问题，子问题互相对立，与原问题形式相同，将子问题的解合并得到原问题的解 工作窃取 一个大任务分割为若干个互不依赖的子任务，为了减少线程间的竞争，把这些子任务分别放到不同的队列里，并未每个队列创建一个单独的线程来执行队列里的任...
java多核_Java 从单核到多核的多线程（并发）
weixin_39572972的博客
02-12 980
JAVA 并发编程最初计算机是单任务的，然后发展到多任务，接着出现多线程并行，同时计算机也从单cpu进入到多cpu。如下图：多任务：其实就是利用操作系统时间片轮转使用的原理。操作系统通过将cpu的执行时间分割成多个时间片，为每个任务分配时间片，因为cpu处理速度很快，这样就用户看来好像每个任务都在同时执行，感觉有多个cpu，但本质上一个时间点只有一个任务在运行。随着多核多线程的出现，我们可以更好的...
java8 ParallelStream 的并行体验,利用多核机器加快计算速度
weixin_39715061的博客
03-08 7574
我们现在cup 进入多核时代, 所以我们测试java8对Stream的并行处理: 对Stream进行并发,并行执行,怎么做呢?我们用Stream来对它进行加法的运算我们用Stream获取到一个大值,用来比较运算时间private static long iterateStream(long limit) {//定义一个上限 return Stream.iterate(1L, i -&gt;...
JDK 7 中的 Fork/Join 模式——轻松实现多核时代的并行计算
AI天才研究院
10-28 8655
介绍随着多核芯片逐渐成为主流，大多数软件开发人员不可避免地需要了解并行编程的知识。而同时，主流程序语言正在将越来越多的并行特性合并到标准库或者语言本身之中。我们可以看到，JDK 在这方面...
Java 从单核到多核的多线程（并发）
guicaizhou的专栏
03-11 8146
JAVA 并发       java的并行编程比较复杂，我也理解不深。但是最近由于要并行训练分类器，琢磨了一点，有错误请指正。只是大体介绍一下而已。       很多问题我们使用顺序编程便可以解决，但是有些问题如果能够使用多线程并行的执行其中的任务则可以很大程度的提高时间效率，所以多线程还是很有必要的。       我自己总结了JAVA并行的3个发展阶段（菜鸟总结，请体谅）       第
java多核并行计算_谈谈Java任务的并行处理
weixin_33419842的博客
02-13 493
前言谈到并行，我们可能最先想到的是线程，多个线程一起运行，来提高我们系统的整体处理速度；为什么使用多个线程就能提高处理速度，因为现在计算机普遍都是多核处理器，我们需要充分利用cpu资源；如果站的更高一点来看，我们每台机器都可以是一个处理节点，多台机器并行处理；并行的处理方式可以说无处不在，本文主要来谈谈Java在并行处理方面的努力。无处不在的并行Java的垃圾回收器，我们可以看到每一代版本的更新，...
java控制多核cpu的占用率
Boush
06-27 5666
测试机型配置如下： 让cpu占用率最高，只要让他时钟周期一直占用就可以了，但是我发现我的cpu是四线程的，i++的while循环只能让cpu工作在25%左右，这主要是因为只有一个线程在满负荷运行，100%分担到四个核心就只有25%了，在我开启两个线程的情况下，负荷在50%左右，如下图： 可以很清楚的看到只有两个核心是在满负荷工作，下图是开启全部四个核心： Boush表
多核、超线程CPU时代将成就Java性能之王的地位
【良少课堂】
11-19 5884
  多核、超线程CPU时代将成就Java性能之王的地位 传统上提升CPU性能的主要手段是提高CPU的主频。但是，经过30多年的发展，CPU的主频速度已经接近物理极限，很难再提高CPU的主频。现在，CPU已经进入了超线程、多核CPU的时代。为了提高CPU的运算性能，现在只有使用具有超线程技术的多核CPU。传统的CPU，只有一个内核，这个内核也只能够同时运行一个线程。采用超线程技术
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值