Java CountedCompleter 与 ForkJoinTask 的代码篇

最新推荐文章于 2022-09-09 16:57:33 发布
最新推荐文章于 2022-09-09 16:57:33 发布
阅读量187 收藏
点赞数
分类专栏： java 文章标签： java ForkJoinTask Completer 分治算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44245828/article/details/111146050
版权

在看 ConcurrentHashMap 的源码时，BulkTask extends CountedCompleter，CountedCompleter extends ForkJoinTask，那么我们也按照这个继承顺序，一探究竟。

1. invoke 看 ForkJoinTask 的各种状态值

  • 实体类
import java.util.concurrent.CountedCompleter;

public class MyForkJoinTask<R> extends CountedCompleter<R> {
    static int i = 1;
    public MyForkJoinTask() {
    }

    @Override
    public void compute() {
        try {
            /* 特定的设置为 EXCEPTIONAL */
            if(i == 2) completeExceptionally(new Exception());
        } catch (Exception e) {
            e.printStackTrace();
        }
        i++;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        /* 不让 SIGNAL 设置完成*/
        if(i != 5) propagateCompletion();
    }
}
  • 测试类
import java.lang.reflect.Field;

public class MyForkJoinTaskTest01 {
    public static void main(String[] args) throws Exception {
        MyForkJoinTask<Object> myForkJoinTask01 = new MyForkJoinTask<>();
        MyForkJoinTask<Object> myForkJoinTask02 = new MyForkJoinTask<>();
        MyForkJoinTask<Object> myForkJoinTask03 = new MyForkJoinTask<>();
        MyForkJoinTask<Object> myForkJoinTask04 = new MyForkJoinTask<>();
        MyForkJoinTask<Object> myForkJoinTask05 = new MyForkJoinTask<>();
        MyForkJoinTask<Object> myForkJoinTask06 = new MyForkJoinTask<>();

        Field status01 =  myForkJoinTask01.getClass().getSuperclass().getSuperclass().getDeclaredField("status");
        Field status02 =  myForkJoinTask02.getClass().getSuperclass().getSuperclass().getDeclaredField("status");
        Field status03 =  myForkJoinTask03.getClass().getSuperclass().getSuperclass().getDeclaredField("status");
        Field status04 =  myForkJoinTask04.getClass().getSuperclass().getSuperclass().getDeclaredField("status");
        Field status05 =  myForkJoinTask05.getClass().getSuperclass().getSuperclass().getDeclaredField("status");
        Field status06 =  myForkJoinTask06.getClass().getSuperclass().getSuperclass().getDeclaredField("status");
        status01.setAccessible(true);
        status02.setAccessible(true);
        status03.setAccessible(true);
        status04.setAccessible(true);
        status05.setAccessible(true);
        status06.setAccessible(true);

        new Thread(() -> {
            try {
                Thread.sleep(500);
                System.out.println("=================");
                myForkJoinTask01.cancel(true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
        try{
            /* 半路取消，CANCELLED */
            myForkJoinTask01.invoke();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
            /* 直接取消，CANCELLED */
            myForkJoinTask02.cancel(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
            /* 设置成 EXCEPTIONAL */
            myForkJoinTask03.invoke();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
            /* 正常执行完成 */
            myForkJoinTask04.invoke();
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("================ myForkJoinTask01 ================");
        System.out.print("status: " + Integer.toHexString((Integer) status01.get(myForkJoinTask01)) + "\t CANCELLED   = 0xc0000000"+ "\t");
        System.out.print("isCancelled(): " + myForkJoinTask01.isCancelled() + " \t");
        System.out.print("isDone(): " + myForkJoinTask01.isDone() + "\t");
        System.out.print("isCompletedAbnormally(): " + myForkJoinTask01.isCompletedAbnormally() + "\t");
        System.out.print("isCompletedNormally(): " + myForkJoinTask01.isCompletedNormally() + "\t");
        System.out.println();
        System.out.println("================== myForkJoinTask02 ===================");
        System.out.print("status: " + Integer.toHexString((Integer) status02.get(myForkJoinTask02)) + "\t CANCELLED = 0xc0000000"+ "\t");
        System.out.print("isCancelled(): " + myForkJoinTask02.isCancelled() + "\t");
        System.out.print("isDone(): " + myForkJoinTask02.isDone() + "\t");
        System.out.print("isCompletedAbnormally(): " + myForkJoinTask02.isCompletedAbnormally() + "\t");
        System.out.print("isCompletedNormally(): " + myForkJoinTask02.isCompletedNormally() + "\t");
        System.out.println();
        System.out.println("================= myForkJoinTask03 ====================");
        System.out.print("status: " + Integer.toHexString((Integer) status03.get(myForkJoinTask03)) + "\t EXCEPTIONAL     = 0x80000000;"+ "\t");
        System.out.print("isCancelled(): " + myForkJoinTask03.isCancelled() + "\t");
        System.out.print("isDone(): " + myForkJoinTask03.isDone() + "\t");
        System.out.print("isCompletedAbnormally(): " + myForkJoinTask03.isCompletedAbnormally() + "\t");
        System.out.print("isCompletedNormally(): " + myForkJoinTask03.isCompletedNormally() + "\t");
        System.out.println();
        System.out.println("================= myForkJoinTask04 ====================");
        System.out.print("status: " + Integer.toHexString((Integer) status04.get(myForkJoinTask04)) + "\t NORMAL     = 0xf0000000;"+ "\t");
        System.out.print("isCancelled(): " + myForkJoinTask04.isCancelled() + "\t");
        System.out.print("isDone(): " + myForkJoinTask04.isDone() + "\t");
        System.out.print("isCompletedAbnormally(): " + myForkJoinTask04.isCompletedAbnormally() + "\t");
        System.out.print("isCompletedNormally(): " + myForkJoinTask04.isCompletedNormally() + "\t");
        System.out.println();
        System.out.println("================= myForkJoinTask05 ====================");
        System.out.print("status: " + Integer.toHexString((Integer) status05.get(myForkJoinTask05)) + "\t 初始化 status     = 0;"+ "\t");
        System.out.print("isCancelled(): " + myForkJoinTask05.isCancelled() + "\t");
        System.out.print("isDone(): " + myForkJoinTask05.isDone() + "\t");
        System.out.print("isCompletedAbnormally(): " + myForkJoinTask05.isCompletedAbnormally() + "\t");
        System.out.print("isCompletedNormally(): " + myForkJoinTask05.isCompletedNormally() + "\t");
        System.out.println();


        System.out.println("=============================================");
        new Thread(() -> {
            try {
                Thread.sleep(2000);
                System.out.println("================= myForkJoinTask06 ====================");
                System.out.print("status: " + Integer.toHexString((Integer) status06.get(myForkJoinTask06)) + "\t SIGNAL     = 0x00010000;"+ "\t");
                System.out.print("isCancelled(): " + myForkJoinTask06.isCancelled() + "\t");
                System.out.print("isDone(): " + myForkJoinTask06.isDone() + "\t");
                System.out.print("isCompletedAbnormally(): " + myForkJoinTask06.isCompletedAbnormally() + "\t");
                System.out.print("isCompletedNormally(): " + myForkJoinTask06.isCompletedNormally() + "\t");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
        try{
            /* invoke 执行 */
            System.out.println("myForkJoinTask06 开始执行");
            myForkJoinTask06.invoke();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

2. 为什么使用 invoke()，而不直接使用 compute() ？

  • 先说结论，invoke() 会等待全部任务完成，compute()执行完当前任务则退出。
  • 实体类
import java.util.concurrent.CountedCompleter;

public class MyForkJoinTask02<R> extends CountedCompleter<R> {
    int batch = 0;

    public MyForkJoinTask02(CountedCompleter<?> completer, int batch) {
        super(completer);
        this.batch = batch;
    }

    @Override
    public void compute() {
        for (;batch > 0;) {
            addToPendingCount(1);
            new MyForkJoinTask02<R>(this, batch >>>= 1).fork();
        }
        System.out.println("now batch = " + batch);
        propagateCompletion();
    }
}
  • 测试类
public class MyForkJoinTaskTest02 {
    public static void main(String[] args) throws InterruptedException {

        MyForkJoinTask02<Object> myForkJoinTask = new MyForkJoinTask02<>(null, 5);
        MyForkJoinTask02<Object> myForkJoinTask02 = new MyForkJoinTask02<>(null, 5);
        myForkJoinTask.invoke();
        System.out.println("========== 华丽分割线 =========");
        myForkJoinTask02.compute();
        System.out.println("===========================");
        myForkJoinTask02.join();

    }
}

在这里插入图片描述

3. 异常存储之 exceptionTable

  • 实体类
package cn.cerish.forkJoin;

import java.util.concurrent.CountedCompleter;

public class MyForkJoinTask03<R> extends CountedCompleter<R> {
    static int i = 0;
    int batch;
    public MyForkJoinTask03(CountedCompleter<?> completer, int batch) {
        super(completer);
        this.batch = batch;
    }
    /* 抛出不同种类的错误 */
    @Override
    public void compute() {
        i++;
        if(i == 1) completeExceptionally(new RuntimeException());
        if(i == 2) completeExceptionally(new NoSuchFieldException());
        if(i == 3) completeExceptionally(new IndexOutOfBoundsException());
    }
}
  • 测试类
import java.lang.reflect.Field;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class MyForkJoinTaskTest03 {
    public static void main(String[] args) throws Exception {

        MyForkJoinTask03<String> myForkJoinTask01 = new MyForkJoinTask03<>(null, 1);
        MyForkJoinTask03<String> myForkJoinTask02 = new MyForkJoinTask03<>(null, 1);
        MyForkJoinTask03<String> myForkJoinTask03 = new MyForkJoinTask03<>(null, 1);
        MyForkJoinTask03<String> myForkJoinTask04 = new MyForkJoinTask03<>(null, 1);
        Class<?> forkJoinTaskClass = myForkJoinTask01.getClass().getSuperclass().getSuperclass();
        Field exceptionTable = forkJoinTaskClass.getDeclaredField("exceptionTable");
        exceptionTable.setAccessible(true);
        try{
            myForkJoinTask01.invoke();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
            myForkJoinTask02.invoke();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
            myForkJoinTask03.invoke();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("====================== myForkJoinTask01 ====================");
        System.out.println("getException(): " + myForkJoinTask01.getException() + "\t");
        System.out.print("getCompleter(): " + myForkJoinTask01.getCompleter() + "\t");
        System.out.print("getForkJoinTaskTag(): " + myForkJoinTask01.getForkJoinTaskTag() + "\t");
        System.out.print("getPendingCount(): " + myForkJoinTask01.getPendingCount() + "\t");
        System.out.print("getRawResult(): " + myForkJoinTask01.getRawResult() + "\t");
        System.out.println();
        System.out.println("====================== myForkJoinTask02 ====================");
        System.out.println("getException(): " + myForkJoinTask02.getException() + "\t");
        System.out.print("getCompleter(): " + myForkJoinTask02.getCompleter() + "\t");
        System.out.print("getForkJoinTaskTag(): " + myForkJoinTask02.getForkJoinTaskTag() + "\t");
        System.out.print("getPendingCount(): " + myForkJoinTask02.getPendingCount() + "\t");
        System.out.print("getRawResult(): " + myForkJoinTask02.getRawResult() + "\t");
        System.out.println();
        System.out.println("===================== myForkJoinTask03 =======================");
        System.out.println("getException(): " + myForkJoinTask03.getException() + "\t");
        System.out.print("getCompleter(): " + myForkJoinTask03.getCompleter() + "\t");
        System.out.print("getForkJoinTaskTag(): " + myForkJoinTask03.getForkJoinTaskTag() + "\t");
        System.out.print("getPendingCount(): " + myForkJoinTask03.getPendingCount() + "\t");
        System.out.print("getRawResult(): " + myForkJoinTask03.getRawResult() + "\t");
        System.out.println();
        System.out.println("=============== myForkJoinTask04 用来查看 exceptionTable ===============");
        Object[] objects = (Object[]) exceptionTable.get(myForkJoinTask04);
        for (Object object : objects) {
            if(object != null) System.out.println(object);
        }
        myForkJoinTask03.reinitialize();
        System.out.println("=============== myForkJoinTask03.reinitialize() 清除错误状态 ===============");
        Object[] objects01 = (Object[]) exceptionTable.get(myForkJoinTask04);
        for (Object object : objects01) {
            if(object != null) System.out.println(object);
        }
    }
}

在这里插入图片描述

4. ForkJoinTask 中的 Runnable、Callable

import java.util.concurrent.ForkJoinTask;

public class MyForkJoinTaskTest04 {
    public static void main(String[] args) throws Exception {
        ForkJoinTask<?> adapt01 = ForkJoinTask.adapt(() -> {
            System.out.println("I am Runnable(), 我的返回值默认为null即没有返回值");
        });
        System.out.println("adapt01.invoke(): " + adapt01.invoke());
        System.out.println("================== 华丽分割线 ====================");
        ForkJoinTask<Integer> adapt02 = ForkJoinTask.adapt(() -> {
            System.out.println("I am Runnable(), 在下是有返回值的");
        }, 100);
        System.out.println("adapt02.invoke(): " + adapt02.invoke());
        System.out.println("================== 华丽分割线 ====================");
        ForkJoinTask<String> adapt03 = ForkJoinTask.adapt(() -> {
            System.out.println("I am Callable(), 在下是有返回值的，直接方法内返回");
            return "I am return value for Callable()";
        });
        System.out.println("adapt03.invoke(): " + adapt03.invoke());

    }
}

在这里插入图片描述

cerish404
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
164个完整的Java源程序代码
01-09
164个完整的Java源程序代码
Java ForkJoinPool初探
我要上天和太阳肩并肩的专栏
06-09 1034
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习..
并发编程：fork/join框架：异步地运行任务（CountedCompleter）
博风_刺耳的博客
08-28 964
CountedCompleter，异步地运行任务。
关于CountedCompleter的一个示例的解读
老卡的博客
07-08 309
在CountedCompleter的类注释中，有个关于CountedCompleter如何应用到MapReduce场景的示例代码，这里稍微理了下思路。 示例如下： class MapReducer<E> extends CountedCompleter<E>{ final E[] array; final MyMapper<E> mapper; final MyReducer<E> reducer; fi...
Java8 RecursiveAction / RecursiveTask / CountedCompleter 源码解析
菜鸟进阶之路
04-25 1271
目录 一、RecursiveAction 1、普通的递归实现 2、非递归实现 二、RecursiveTask 三、CountedCompleter 1、定义 2、BulkTask 3、ForEachMappingTask 4、ReduceEntriesTask 5、SearchEntriesTask 6、complete /tryComplete /helpComple...
java进阶笔记线程与并发之CountedCompleter
huitoukest的专栏
10-21 2555
说明 CountedCompleter是ForkJoinTask的一个子类。 其可以简单理解为处理业务和数量有关的一些FJT，一般分为如下几类： 和数量无关，一般不使用CountedCompleter 一个： findAny、searchFirst这种操作，只要在集合、流中找到一个就表示整个任务完成的 指定数量的： 比如有的业务需要触发多次完成的。 可能需要有序完成的，有序完成可以通过Count...
经典的java小程序源代码合集
12-21
164个完美程序,五子棋,俄罗斯方块,扫雷,聊天程序
java项目开发10例源代码
03-18
java的实例10个 源代码 供大家参考 从桌面软件到网页设计到企业项目，手游都有，可能有些已过时，但学习一下也好的
Java 45款 游戏源代码
12-01
Java 45款 游戏源代码，包括： 3D卡丁车、4种牌类游戏、6270原装贪吃蛇、Goldminer挖金、阿猫阿狗、埃及祖玛、大富翁中国之旅+最新版、斗地主、美女连连看等，太多了，下了再看吧。
java新浪微博（含源代码）
12-14
java新浪微博（含源代码）
java CountedCompleter 源码详解
weixin_44245828的博客
12-12 257
1. CountedCompleter 的类定义 CountedCompleter 继承了 ForkJoinTask，即为一个异步任务 public abstract class CountedCompleter<T> extends ForkJoinTask<T> {} 1.1 CountedCompleter 的构造函数 CountedCompleter 共有三个构造函数 protected CountedCompleter(CountedCompleter<?&
并发-CountedCompleter详解
beFocused的博客
03-01 1303
CountedCompleter维护两个动作：onCompletion)和onExceptionalCompletion CountedCompleter维护父任务变量completer，通过这个变量逐级传递上去 CountedCompleter维护挂起任务(子任务)的计数(pending)，子任务完成会触发父任务的pending减1 作为ForkJoinTask，compute之后并没有将状态置为Normal，如果此时调用join会阻塞线程
ForkJoinPool的CountedCompleter源码分析
heng_zou的博客
06-25 311
CountedCompleter直译是计数的完成器，其使用方式和原理相比RecursiveTask和RecursiveAction相对要复杂，因此案例不多，实际上源码中已经提供了较为详细的说明和使用案例，主要能实现在任务完成时触发一个特定的自定义操作。源码文档比较晦涩，直接分析源码。CountedCompleter新增了两个成员变量： /** *当前任务挂起的子任务数，ForkJoinTask的一大特色就是分治任务的拆分，一个大的任务拆分成多个子任务， *子任务在进行细拆，因此任务和任务之间就形成了层级父子
CountedCompleter使用方法小洁
Xp545945的博客
05-28 1337
CountedCompleter将结果合并从任务分解计算的过程中分离出来，只要每个子任务能保存状态，那么通过合并逻辑，就可以在任何时候将结果合并。 CountedCompleter中如何知道子任务计算完成？它使用了一个孩子兄弟表示的树形结构。用一个变量统计当前一个节点的子节点个数，兄弟节点通过判断计算器可以知道其他兄弟任务是否完成，如果没有完成就将计数器减一表示自己已经完成。如果完成了就将所有兄弟任务的结果合并（合并顺序可以自定义），然后递归判断父节点的情况。这样最终就可以将任务结果合并到根节点。 因此
ForkJoin全解3：CountedCompleter
yu766588220的专栏
06-20 606
1、使用示例 import java.util.concurrent.CountedCompleter; import java.util.concurrent.atomic.AtomicInteger; public class CountedCompleterDemo { interface Applier<E>{ void apply(E e); } static class ForEach<E> extends CountedCo
servlet的生命周期
weixin_44939921的博客
09-18 143
什么是servlet的生命周期？ servlet的生命周期是指：servlet对象什么时候实例化，什么时候初始化，什么时候调用方法，什么时候销毁。 实例化： servlet的实例化有两种情况： （1）默认情况下servlet是在请求的时候实例化； （2）web容器启动的时候实例化。这种情况需要在web.xml中配置<load-on-starup>1</load-on-starup>，数值越小表示优先级越高。 初始化：
Java 编程问题：十一、并发-深入探索
龙哥盟
07-09 1554
Java 编程问题：十一、并发-深入探索
CountedCompleter的示例
wb1983的专栏
09-09 175
countedCompleter
ConcurrentHashMap 源码分析04之内部类ReduceTask
weixin_44245828的博客
12-02 269
1.3.35 ReduceKeysTask @SuppressWarnings("serial") static final class ReduceKeysTask<K,V> extends BulkTask<K,V,K> { final BiFunction<? super K, ? super K, ? extends K> reducer; K result; ReduceKeysTask<K,V> rights, ne
Java接口与多态代码
最新发布
04-18
下面是Java接口和多态的示例代码： // Java接口示例代码 interface Animal { public void sound(); // 声明一个抽象方法 } class Dog implements Animal { public void sound() { System.out.println("汪汪汪")...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值