java.util.concurrent 包源码分析之Fork/Join框架

本文详细分析了Java 7引入的Fork/Join框架,它采用分治策略,通过Fork分解任务,Join合并结果。关键类包括ForkJoinTask及其子类RecursiveAction和RecursiveTask,以及ForkJoinPool。工作线程ForkJoinWorkerThread使用双端队列和工作窃取算法提高并发性能。ForkJoinTask的fork和join方法是核心,join方法涉及多线程间的同步等待。
摘要由CSDN通过智能技术生成

在JDK7引入了Fork/Join框架,所谓Fork/Join框架,个人理解,有一种分治的策略在里边:Fork分解任务成独立的子任务,用多线程去执行这些子任务,Join合并子任务的结果。这样就能使用多线程的方式来执行一个任务。

JDK7引入的Fork/Join有三个核心类:

ForkJoinPool,执行任务的线程池

ForkJoinWorkerThread,执行任务的工作线程

ForkJoinTask,一个用于ForkJoinPool的任务抽象类。

我们已经很清楚Fork/Join框架的需求了,那么我们可以思考一下,如果让我们来设计一个Fork/Join框架,该如何设计?这个思考有助于你理解Fork/Join框架的设计。

第一步分割任务。首先我们需要有一个fork类来把大任务分割成子任务,有可能子任务还是很大,所以还需要不停的分割,直到分割出的子任务足够小。

第二步执行任务并合并结果。分割的子任务分别放在双端队列里,然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都统一放在一个队列里,启动一个线程从队列里拿数据,然后合并这些数据。

Fork/Join使用两个类来完成以上两件事情:

ForkJoinTask:我们要使用ForkJoin框架,必须首先创建一个ForkJoin任务。它提供在任务中执行fork()和join()操作的机制,通常情况下我们不需要直接继承ForkJoinTask类,而只需要继承它的子类,Fork/Join框架提供了以下两个子类:

    RecursiveAction:用于没有返回结果的任务。
    RecursiveTask :用于有返回结果的任务。

ForkJoinPool :ForkJoinTask需要通过ForkJoinPool来执行,任务分割出的子任务会添加到当前工作线程所维护的双端队列中,进入队列的头部。当一个工作线程的队列里暂时没有任务时,它会随机从其他工作线程的队列的尾部获取一个任务。

    public 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;  
        }  

    }  

而执行该自定义任务的调用的则是ForkJoinPool的execute方法,因此首先来看的就是ForkJoinPool的execute方法,看看和普通线程池执行任务有什么不同:

  public void execute(ForkJoinTask<?> task) {
        if (task == null)
            throw new NullPointerException();
        forkOrSubmit(task);
    }

因此forkOrSubmit是真正执行ForkJoinTask的方法:

   private <T> void forkOrSubmit(ForkJoinTask<T> task) {
        ForkJoinWorkerThread w;
        Thread t = Thread.currentThread();
        if (shutdown)
            throw new RejectedExecutionException();
        if ((t instanceof ForkJoinWorkerThread) &&
            (w = (ForkJoinWorkerThread)t).pool == this)
            w.pushTask(task);
        else
            // 正常执行的时候是主线程调用的,因此关注addSubmission
            addSubmission(task);
    }

那么我们首先要关注的是addSubmission方法,发觉所做的事情和普通线程池很类似,就是把任务加入到队列中,不同的是直接使用Unsafe操作内存来添加任务对象

   private void addSubmission(ForkJoinTask<?> t) {
        final ReentrantLock lock = this.submissionLock;
        lock.lock();
        try {
            // 队列只是普通的数组而不是普通线程池的BlockingQueue,
            // 唤醒worker线程的工作由下面的signalWork来完成
            // 使用Unsafe进行内存操作,把任务放置在数组中
            ForkJoinTask<?>[] q; int s, m;
            if ((q = submissionQueue) != null) {
                long u = (((s = queueTop) & (m = q.length-1)) << ASHIFT)+ABASE;
                UNSAFE.putOrderedObject(q, u, t);
                queueTop = s + 1;
                if (s - queueBase == m)
                    // 数组已满,为数组扩容
                    growSubmissionQueue();
            }
        } finally {
            lock.unlock();
        }
        // 通知有新任务来了:两种操作,有空闲线程则唤醒该线程
        // 否则如果可以新建worker线程则为这个任务新建worker线程
        // 如果不可以就返回了,等到有空闲线程来执行这个任务
        signalWork();
    }

接下来要弄清楚就是在compute中fork时,按道理来说这个动作是和主任务在同一个线程中执行,fork是如果把子任务变成多线程执行的:

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值