【fork/join】java并发编程-fork/join示例

package com.chinamobile.epic.tako.common.graphite.query.sync.impl;

import com.google.common.collect.Lists;

import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeUnit;

public class GraphiteQueryTask extends RecursiveTask<List<String>> {
    private List<String> uuids;

    private int THRESHOLD = 12;

    public GraphiteQueryTask(List<String> uuids) {
        this.uuids = uuids;
    }

    public static void main(String[] args) {
        ForkJoinPool pool = ForkJoinPool.commonPool();

        List<String> uuids = Lists.newArrayList();
        for (int i = 0; i < 40; i++) {
            uuids.add("uuid-" + i);
        }

        List<String> result = pool.invoke(new GraphiteQueryTask(uuids));
        System.out.println("========== 结果 ============");
        System.out.println(result);

    }

    @Override
    protected List<String> compute() {
        List<String> result = Lists.newArrayList();
        List<GraphiteQueryTask> forks = Lists.newArrayList();

        if (uuids.size() > THRESHOLD) {
            int mid = uuids.size() >>> 1;
            GraphiteQueryTask firstTask = new GraphiteQueryTask(Lists.newArrayList(uuids.subList(0, mid)));
            GraphiteQueryTask secondTask = new GraphiteQueryTask(Lists.newArrayList(uuids.subList(mid, uuids.size())));
            forks.add(firstTask);
            forks.add(secondTask);
            ForkJoinTask.invokeAll(forks);
        } else {
            result.add(postGraphite(uuids));
        }

        for (RecursiveTask<List<String>> task : forks) {
            result.addAll(task.join());
        }

        return result;
    }

    private String postGraphite(List<String> uuids) {
        System.out.println("============>ThreadId: [" + Thread.currentThread().getId() + "] , uuids.size:[" + uuids.size() + "]");
        System.out.println(uuids);

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        return "@@@-" + Thread.currentThread().getId() + "-" + uuids.size();
    }
}

http://www.baeldung.com/java-fork-join

原文地址:https://www.cnblogs.com/ssslinppp/p/8747252.html

时间: 2024-08-10 11:48:47

【fork/join】java并发编程-fork/join示例的相关文章

Java 并发编程 -- Fork/Join 框架

概述 Fork/Join 框架是 Java7 提供的一个用于并行执行任务的框架,是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架.下图是网上流传的 Fork Join 的运行流程图,直接拿过来用了: 工作窃取算法 工作窃取(work-stealing)算法是指某个线程从其他队列里窃取任务来执行.那么为什么要使用这个算法呢?假如我们需要做一个比较大的任务,可以把这个任务分割为若干个互不依赖的子任务,为了减少线程间的竞争,把这些子任务分别放到不同的队列里,并为每个队列创

Java并发编程--Fork/Join框架使用

上篇博客我们介绍了通过CyclicBarrier使线程同步,但是上述方法存在一个问题,那就是如果一个大任务跑了2个线程去完成,如果线程2耗时比线程1多2倍,线程1完成后必须等待线程2完成,等待的过程线程1没法复用.现在我们准备解决这个问题,我们希望线程1完成自己的任务后能去帮助线程2完成一部分任务.Java7引如了Fork/Join框架可以很好的解决这个问题. Fork/Join是一个用于并行执行任务的框架,是一个把大任务分割成若干个小任务,最后汇总每个小任务结果后得到大任务结果的框架.fork

Java 并发编程:volatile的使用及其原理

Java并发编程系列[未完]: Java 并发编程:核心理论 Java并发编程:Synchronized及其实现原理 Java并发编程:Synchronized底层优化(轻量级锁.偏向锁) Java 并发编程:线程间的协作(wait/notify/sleep/yield/join) Java 并发编程:volatile的使用及其原理 一.volatile的作用 在<a href="http://www.cnblogs.com/paddix/p/5374810.html">&

Java 并发编程:线程间的协作(wait/notify/sleep/yield/join)

Java并发编程系列[未完]: Java 并发编程:核心理论 Java并发编程:Synchronized及其实现原理 Java并发编程:Synchronized底层优化(轻量级锁.偏向锁) Java 并发编程:线程间的协作(wait/notify/sleep/yield/join) 一.线程的状态 Java中线程中状态可分为五种:New(新建状态),Runnable(就绪状态),Running(运行状态),Blocked(阻塞状态),Dead(死亡状态). New:新建状态,当线程创建完成时为新

读Java并发编程实践中,向已有线程安全类添加功能--客户端加锁实现示例

在Java并发编程实践中4.4中提到向客户端加锁的方法.此为验证示例,写的不好,但可以看出结果来. package com.blackbread.test; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public

JAVA并发编程J.U.C学习总结

前言 学习了一段时间J.U.C,打算做个小结,个人感觉总结还是非常重要,要不然总感觉知识点零零散散的. 有错误也欢迎指正,大家共同进步: 另外,转载请注明链接,写篇文章不容易啊,http://www.cnblogs.com/chenpi/p/5614290.html 本文目录如下,基本上涵盖了J.U.C的主要内容: JSR 166及J.U.C Executor框架(线程池. Callable .Future) AbstractQueuedSynchronizer(AQS框架) Locks & C

java并发编程实战

java并发编程实战 Fork/Join 框架是JDK7提供的一个用于并行执行任务的框架,是一个把大任务切分为若干子任务并行的执行,最终汇总每个小任务后得到大任务结果的框架.我们再通过 Fork和Join来理解下Fork/Join框架.Fork就是把一个大任务划分成为若干子任务并行的执行,Join就是合并这些子任务的执行结果,最 后得到这个大任务的结果. 使 用Fork/Join框架时,首先需要创建一个ForkJoin任务(基础教程qkxue.net),它提供在任务中执行fork()和join操

Java并发编程深入学习

基本概念 在实践中,为了更好的利用资源提高系统整体的吞吐量,会选择并发编程.但由于上下文切换和死锁等问题,并发编程不一定能提高性能,因此如何合理的进行并发编程时本文的重点,接下来介绍关于锁最基本的一些知识(选学). volatile:轻量,保证共享变量的可见性,使得多个线程对共享变量的变更都能及时获取到.其包括两个子过程,将当前处理器缓存行的数据写回到系统内存,之后会使其他CPU里缓存了该内存地址的数据无效. synchronized:相对重量,其包含3种形式,针对普通同步方法,锁是当前实例对象

Java并发编程有多难?这几个核心技术你掌握了吗?

本文主要内容索引 1.Java线程 2.线程模型 3.Java线程池 4.Future(各种Future) 5.Fork/Join框架 6.volatile 7.CAS(原子操作) 8.AQS(并发同步框架) 9.synchronized(同步锁) 10.并发队列(阻塞队列) 本文仅分析java并发编程中的若干核心问题,对于上面没有提到但是又和java并发编程有密切关系的技术将会不断添加进来完善文章,本文将长期更新,不断迭代.本文试图从一个更高的视觉来总结Java语言中的并发编程内容,希望阅读完