fork-join(多线程),主线程-分线程-主线程,通知返回

发烧友 21:58:01
import java.util.Date;
import java.util.concurrent.RecursiveTask;

public class TstForkJoin {

public static void main(String args[]) {
        new TstForkJoin().start();
    }

private void start() {
        /*ForkJoinPool forkJoinPool = new ForkJoinPool();
        Future<Integer> result = forkJoinPool.submit(new Calculator(0, 10000));
        try {
            System.out.print(result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }*/
        System.out.println(new Date());
        TstFJ1 tstFJ1 = new TstFJ1(4000);
        TstFJ2 tstFJ2 = new TstFJ2(7000);
        tstFJ1.fork();
        tstFJ2.fork();
        System.out.println(new Date());
        Integer sum = tstFJ1.join() + tstFJ2.join();
        System.out.println(new Date());
        System.out.print(sum);
    }

static class Calculator extends RecursiveTask<Integer> {

private static final int THRESHOLD = 100;
        private int start;
        private int end;

public Calculator(int start, int end) {
            this.start = start;
            this.end = end;
        }

@Override
        protected Integer compute() {
            int sum = 0;
            if ((start - end) < THRESHOLD) {
                for (int i = start; i < end; i++) {
                    sum += i;
                }
            } else {
                int middle = (start + end) / 2;
                Calculator left = new Calculator(start, middle);
                Calculator right = new Calculator(middle + 1, end);
                left.fork();
                right.fork();

sum = left.join() + right.join();
            }
            return sum;
        }
    }

class TstFJ1 extends RecursiveTask<Integer> {
        Integer times;

public TstFJ1(Integer times) {
            System.out.println(times);
            this.times = times;
        }

@Override
        protected Integer compute() {
            try {
                Thread.sleep(times);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times > 5000) {
                return 1;
            } else {
                return 0;
            }
        }
    }

class TstFJ2 extends RecursiveTask<Integer> {
        Integer times;

public TstFJ2(Integer times) {
            System.out.println(times);
            this.times = times;
        }

@Override
        protected Integer compute() {
            try {
                Thread.sleep(times);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times > 5000) {
                return 1;
            } else {
                return 0;
            }
        }
    }
}
韩宏远  11:37:10
http://www.iteye.com/topic/643724
http://www.infoq.com/cn/articles/fork-join-introduction/
韩宏远  11:39:35
发烧友 21:58:57
写了一个并行计算的例子,可以用在接口校验上
发烧友 22:00:29
Wed Jun 29 21:56:39 CST 2016
4000
7000
Wed Jun 29 21:56:39 CST 2016
Wed Jun 29 21:56:46 CST 2016
1
发烧友 22:05:04
两个任务可以看做校验任务,校验正确返回0,错误返回1,一个4秒一个7秒,并行运算结果用时7秒
如果两个都返回0,认为校验正确,则执行文档插入,否则返回错误,
明天傲冰把校验改为并行方式

时间: 2024-10-08 09:30:40

fork-join(多线程),主线程-分线程-主线程,通知返回的相关文章

Java多线程--让主线程等待所有子线程执行完毕 join

首先从公司一道笔试题开始 1 package test; 2 3 public class Test implements Runnable { 4 5 public int i = 0; 6 7 @Override 8 public void run() { 9 try { 10 Thread.sleep(1000); 11 } catch (InterruptedException e) { 12 // TODO Auto-generated catch block 13 e.printSt

Java多线程--让主线程等待所有子线程执行完毕

数据量很大百万条记录,因此考虑到要用多线程并发执行,在写的过程中又遇到问题,我想统计所有子进程执行完毕总共的耗时,在第一个子进程创建前记录当前时间用System.currentTimeMillis()在最后一个子进程结束后记录当前时间,两次一减得到的时间差即为总共的用时,代码如下 Java代码   long tStart = System.currentTimeMillis(); System.out.println(Thread.currentThread().getName() + "开始&

Java多线程、主线程等待所有子线程执行完毕、共享资源

1.Java创建与启动线程 Java提供两种方式创建和启动线程:1.直接Thread类,2.实现Runable接口. 1.1  继承Thread类 public class myThread extends Thread { public void run(){ for(int i=0;i<5;i++){ System.out.println(this.getName()+":"+i); } } public static void main(String[] args){ //

多线程同步-主线程等待所有子线程完成案例

有时候我们会遇到这样的问题:做一个大的事情可以被分解为做一系列相似的小的事情,而小的事情无非就是参数上有可能不相同而已! 此时,如果不使用线程,我们势必会浪费非常多的时间来完成整个大的事情,而使用线程的话将会存在这样的问题: 主线程启动所有子线程并发执行后主线程就直接返回了,导致外部函数判读整个大的事情完成了,但是实际上并没有完成! 针对以上情况我想我会采用多线程方式执行同时解决主线程等待子线程的问题.如图: 在这里我使用Java进行案例分析. 首先建立一个线程管理类,用于启动所有子线程和等待所

[Java][Android] 多线程同步-主线程等待全部子线程完毕案例

有时候我们会遇到这种问题:做一个大的事情能够被分解为做一系列相似的小的事情,而小的事情无非就是參数上有可能不同样而已! 此时,假设不使用线程,我们势必会浪费许多的时间来完毕整个大的事情.而使用线程的话将会存在这种问题: 主线程启动全部子线程并发运行后主线程就直接返回了,导致外部函数判读整个大的事情完毕了,可是实际上并没有完毕! 针对以上情况我想我会採用多线程方式运行同一时候解决主线程等待子线程的问题.如图: watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQ

Unity多线程(Thread)和主线程(MainThread)交互使用类——Loom工具分享

Unity多线程(Thread)和主线程(MainThread)交互使用类——Loom工具分享 By D.S.Qiu 尊重他人的劳动,支持原创,转载请注明出处:http.dsqiu.iteye.com           熟悉Unity的developer都知道在Unity中的线程不能使用Unity的对象,但可以使用Unity的值类型变量,如Vector3等.这样就使得线程在Unity中显的很鸡肋和蹩脚,因为很多函数很都是UnityEngine类或函数的调用的,对于哪些是可以在多线程使用,风雨冲

java主线程等待所有子线程执行完毕在执行(常见面试题)

java主线程等待所有子线程执行完毕在执行(常见面试题) java主线程等待所有子线程执行完毕在执行,这个需求其实我们在工作中经常会用到,比如用户下单一个产品,后台会做一系列的处理,为了提高效率,每个处理都可以用一个线程来执行,所有处理完成了之后才会返回给用户下单成功,下面就说一下我能想到的方法,欢迎大家批评指正: 用sleep方法,让主线程睡眠一段时间,当然这个睡眠时间是主观的时间,是我们自己定的,这个方法不推荐,但是在这里还是写一下,毕竟是解决方法 2.使用Thread的join()等待所有

Java主线程等待所有子线程执行完毕再执行解决办法集

Java主线程等待所有子线程执行完毕在执行,其实在我们的工作中经常的用到,比如说主线程要返回一个响应用户的值,但这个值得赋值过程是由过个子线程来完成的(模拟一个实际开发的情景),所以主线程必须等待子线程执行完毕,再响应用户:否则,响应用户的是一个无意义的值. 那么如何确保所有的子线程执行完毕了.一般的有如下方法: 1  让主线程等待,或着睡眠几分钟.用Thread.sleep()或者TimeUnit.SECONDS.sleep(5); 如下: package andy.thread.tradit

Java主线程如何等待子线程执行结束(转)

工作中往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的产景, 这时候就需要使用线程了. 一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的流程,  往往需要让主线程指定后, 等待子线程的完成. 这里有几种方式. 站在 主线程的角度, 我们可以分为主动式和被动式. 主动式指主线主动去检测某个标志位, 判断子线程是否已经完成. 被动式指主线程被动的等待子线程的结束, 很明显, 比较符合人们的胃口. 就是你事情做完了, 你告诉我, 我汇

Android:主线程如何向子线程发送消息

今天讲一下,在Android中主线程如何向子线程中发送消息的问题. 或许回想无非就是创建一个Handler对象,然后一个线程发消息,另一个接收消息嘛-- 原理确实是这样,但是我们平时,是从子线程向主线程发消息,而主线程默认已经帮我们完成了Looper的操作,所以我们只需要简单的"创建一个Handler对象,然后一个线程发消息,另一个接收消息"-- 我们先说一下这个Looper是神马吧. 它就像一个消息队列(MessageQueue)的管家(Looper),一个消息队列只有一个管家,并且