`
xinklabi
  • 浏览: 1591137 次
  • 性别: Icon_minigender_1
  • 来自: 吉林
文章分类
社区版块
存档分类
最新评论

JDK 7 中的 Fork/Join 模式(并发处理)

 
阅读更多

转自:http://www.ibm.com/developerworks/cn/java/j-lo-forkjoin/

介绍

随着多核芯片逐渐成为主流,大多数软件开发人员不可避免地需要了解并行编程的知识。而同时,

主流程序语言正在将越来越多的并行特性合并到标准库或者语言本身之中。我们可以看到,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,用于并行处理数字类型数组的工具类,提供了排序、查找、
  5. 求和、求最小值、求最大值等功能;

其中,对 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 模式示意图
图 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 将立刻开始执行
  2. ForkJoinTask。
  3. shutdown():执行此方法之后,ForkJoinPool 不再接受新的任务,但是已经提交的任务可以
  4. 继续执行。如果希望立刻停止所有的任务,可以尝试 shutdownNow() 方法。
  5. 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 执行多线程任务
图 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 模式,可以充分享受多核平台为应用带来的免费午餐。

参考资料

学习

  1. Java Fork Join 框架
  2. Oracle官方并发教程之高级并发对象
  3. 定制并发类(八)自定义在 Fork/Join 框架中运行的任务
  4. Java Fork Join 框架(四)性能
  5. Fork and Join: Java也可以轻松地编写并发程序
  6. 分享ppt: java7里的fork-join
  7. Java Fork Join 框架(三)实现
  8. Java Fork Join框架 (二) 简介
  9. 定制并发类(七)实现ThreadFactory接口生成自定义的线程给Fork/Join框架
  10. Oracle官方并发教程之Guarded Blocks
  11. 测试并发应用(四)监控Fork/Join池
  12. Java 7 Concurrency Cookbook – Javier Fernández González -前言
  13. Fork/Join框架(一)引言
  14. 并发性能优化 – 降低锁粒度
  15. Oracle官方并发教程之不可变对象
分享到:
评论

相关推荐

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

    在Java编程中,线程池和并发任务执行是常见的方式,但在某些场景下,我们可以利用JDK的ForkJoin框架来构建更加高效和易用的并发组件。ForkJoin框架自Java 7引入,它为处理大型任务提供了一种分解成多个子任务并行...

    ForkJoin并发框架入门示例

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

    JDK1.7(JavaSE1.7/JDK7)

    在并发编程领域,JDK7引入了Fork/Join框架,这是一种并行计算模型,适用于那些可以拆分为更小子任务的问题,例如在大量数据处理中,能显著提升性能。 JDK7还对垃圾回收机制进行了优化,包括G1(Garbage-First)垃圾...

    jdk7api帮助文档

    而在JDK7中,实现了自动关闭资源的机制,只要资源实现了`java.lang.AutoCloseable`接口,就可以在try块中直接声明并使用,程序结束时会自动调用`close()`方法。 其次,多线程处理方面,JDK7引入了Fork/Join框架,它...

    JDK7 API 中文 文档.CHM

    7. **并发API扩展:**JDK7增加了**`Fork/Join`框架**,用于执行分治算法,还提供了**`ConcurrentHashMap`**的改进版,提高并发性能。 8. **动态代理增强:**Java 7允许接口中存在**默认方法**(default methods),...

    jdk7-aarch64-uos.tar.gz

    例如,动态语言支持、Fork/Join框架、并发工具的增强以及新的编译器——CTW(Compartment Type-Wise)等。这些更新显著提高了开发效率和程序性能。 针对Aarch64(也称为ARM64或AArch64)架构,这是一种64位指令集...

    jdk8文件【版本号jdk1.8.0_151】

    6. ** 并发改进**:JDK 8在并发编程方面也做了改进,例如`Fork/Join`框架的改进,以及`ConcurrentHashMap`性能的提升。 7. ** Nashorn JavaScript引擎**:JDK 8引入了一个名为Nashorn的JavaScript引擎,允许Java...

    jdk7(Linux 平台jdk7 )

    JDK7引入了许多新特性,例如动态类型语言支持( invokedynamic 指令)、Project Coin的小改进(如 try-with-resources 语句、多 catch 块、改进的类型推断等),以及并发改进(如Fork/Join框架和Parallel Scanning)...

    jdk api 1.8中文API

    在并发编程方面,Fork/Join框架和Parallel Streams的结合使得多核处理器的性能得以充分利用。Fork/Join框架是一种分治策略,通过将大任务分解成小任务来并行执行。而Parallel Streams则自动利用Fork/Join框架,让...

    jdk7-linux-x64.tar.gz

    1. **多线程并发控制**:引入了Fork/Join框架,通过工作窃取算法提高并行计算效率,同时提供了`Phaser`、`CountDownLatch` 和 `CyclicBarrier` 等并发工具类。 2. **Strings in Switch**:在switch语句中可以直接...

    jdk7新特性jdk8新特性

    在Java 7中,通过类型推断,我们可以更简洁地创建泛型实例,省略new表达式后的类型参数。例如: ```java List&lt;String&gt; list = new ArrayList(); // 可以简化为 List&lt;String&gt; list = new ArrayList(); ``` #### 4. ...

    JDk1.8中文帮助文档.zip / 免费下载

    8. **并发改进**:包括Fork/Join框架、并发集合的增强以及新的ConcurrentHashMap实现,提高了多线程环境下的性能和可编程性。 9. **并发工具类**:JDK 1.8增加了新的并发工具类,如Exchanger用于线程间交换数据,...

    jdk-7u80-windows-x64.exe

    "jdk-7" 指的是Java SE(标准版)7,是Java的一个重要版本,引入了多个新特性,如动态类型语言支持( invokedynamic 字节码指令)、Fork/Join框架、并发改进等。"jdk" 是Java Development Kit的缩写,是开发Java应用...

    jdk7官方源码工程

    【标签】"jdk7"指代了Java平台的第七个主要版本,它在2011年发布,引入了许多新的特性,如try-with-resources语句、多线程的Fork/Join框架、改进的类型推断(Project Coin)、文件系统API(NIO.2)以及并发工具的...

    jdk7u25linuxx64.tar

    - 并发改进:如Fork/Join框架和新的并发工具类。 - 编程语言增强:如try-with-resources语句,钻石操作符(),字符串in switch等。 - 类型推断:允许局部变量声明时省略类型,由编译器根据初始化表达式推断。 - NIO...

    jdk api 1.8_google 中文文档.zip

    关于并发处理,JDK 1.8增加了Fork/Join框架和Parallel Streams,这些功能极大地提高了多核处理器环境下并行计算的能力。Fork/Join框架通过将大任务分解为小任务并并行执行来提升性能,而Parallel Streams则利用了...

    jdk7jdk-7u65-windows-x64.rar

    6. **Fork/Join框架**:这是Java并发处理的一个重要改进,它允许将大任务分解为小任务并行执行,从而提高计算密集型应用的性能。 7. **动态类型语言支持**:JDK 7支持JSR 292,即invokedynamic指令,为动态语言提供...

    jdk7源代码

    9. **开关表达式(Switch expressions)**:在JDK 7中是实验性的,后来在JDK 12中成为正式特性,允许将`switch`语句用作表达式,返回值。 10. **并发更新集合**(`ConcurrentHashMap`增强):并发性能得到提升,...

    JDK7api JDKAPI

    2. **`ConcurrentHashMap`的改进**:JDK7中的`ConcurrentHashMap`在并发性能上有了显著提升,提供了更细粒度的锁,减少了锁竞争。 五、其他特性 1. **钻石运算符**:在创建匿名内部类或泛型实例时,可以省略类型...

    7u80windows64位JDK

    2. **多线程增强**:JDK 7的Fork/Join框架提高了多核处理器上的并发性能,使得复杂的并行计算变得更加容易。 3. **NIO.2文件系统接口**:新增的java.nio.file包提供了对文件系统操作的全面支持,包括异步I/O和文件...

Global site tag (gtag.js) - Google Analytics