zoukankan      html  css  js  c++  java
  • fork/join框架

      Java提供底层的线程特性以及线程池之类的高级并发工具类来支持并发。但是,并发的问题在于它无法最大化利用可用的处理器以及核心的资源。举个例子,假如你创建了一种排序算法将一个数组分成两个部分,安排两条线程分别排序每个部分,在线程都完成之后合并结果。

      假设每条线程在不同的处理器上运行。由于不同数量的元素会在数组的每个部分上重新排序,很可能一条线程先于其他线程完成但在合并发生前必须等待。在这种情境下,一个处理器资源就浪费掉了。

      Java提供fork/join通过递归地把任务拆分成子任务然后组合结果的方式解决。

    详细介绍如下引自:https://www.cnblogs.com/dongguacai/p/6021859.html

    一、背景

    虽然目前处理器核心数已经发展到很大数目,但是按任务并发处理并不能完全充分的利用处理器资源,因为一般的应用程序没有那么多的并发处理任务。基于这种现状,考虑把一个任务拆分成多个单元,每个单元分别得到执行,最后合并每个单元的结果。

    Fork/Join框架是JAVA7提供的一个用于并行执行任务的框架,是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。

    fork/join

    二、工作窃取算法

    指的是某个线程从其他队列里窃取任务来执行。使用的场景是一个大任务拆分成多个小任务,为了减少线程间的竞争,把这些子任务分别放到不同的队列中,并且每个队列都有单独的线程来执行队列里的任务,线程和队列一一对应。但是会出现这样一种情况:A线程处理完了自己队列的任务,B线程的队列里还有很多任务要处理。A是一个很热情的线程,想过去帮忙,但是如果两个线程访问同一个队列,会产生竞争,所以A想了一个办法,从双端队列的尾部拿任务执行。而B线程永远是从双端队列的头部拿任务执行(任务是一个个独立的小任务),这样感觉A线程像是小偷在窃取B线程的东西一样。

    work-stealing

    工作窃取算法的优点:

             利用了线程进行并行计算,减少了线程间的竞争。

    工作窃取算法的缺点:

             1、如果双端队列中只有一个任务时,线程间会存在竞争。

             2、窃取算法消耗了更多的系统资源,如会创建多个线程和多个双端队列。

    三、框架设计

     Fork/Join中两个重要的类:

    1、ForkJoinTask:使用该框架,需要创建一个ForkJoin任务,它提供在任务中执行fork和join操作的机制。一般情况下,我们并不需要直接继承ForkJoinTask类,只需要继承它的子类,它的子类有两个:

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

    b、RecursiveTask:用于有返回结果的任务。

    2、ForkJoinPool:任务ForkJoinTask需要通过ForkJoinPool来执行。

    package test;
    
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.Future;
    import java.util.concurrent.RecursiveTask;
    
    
    public class CountTask extends RecursiveTask<Integer>
    {
        private static final long serialVersionUID = 1L;
        //阈值
        private static final int THRESHOLD = 2;
        private int start;
        private int end;
        
        public CountTask(int start, int end)
        {
            this.start = start;
            this.end = end;
        }
    
        @Override
        protected Integer compute()
        {
            int sum = 0;
            //判断任务是否足够小
            boolean canCompute = (end - start) <= THRESHOLD;
            if(canCompute)
            {
                //如果小于阈值,就进行运算
                for(int i=start; i<=end; i++)
                {
                    sum += i;
                }
            }
            else
            {
                //如果大于阈值,就再进行任务拆分
                int middle = (start + end)/2;
                CountTask leftTask = new  CountTask(start,middle);
                CountTask rightTask = new  CountTask(middle+1,end);
                //执行子任务
                leftTask.fork();
                rightTask.fork();
                //等待子任务执行完,并得到执行结果
                int leftResult = leftTask.join();
                int rightResult = rightTask.join();
                //合并子任务
                sum = leftResult + rightResult;
                
            }
            return sum;
        }
        
        public static void main(String[] args)
        {
            ForkJoinPool forkJoinPool = new ForkJoinPool();
            CountTask task = new CountTask(1,6);
            //执行一个任务
            Future<Integer> result = forkJoinPool.submit(task);
            try
            {
                System.out.println(result.get());
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            catch (ExecutionException e)
            {
                e.printStackTrace();
            }
            
        }
        
    }

    这个程序是将1+2+3+4+5+6拆分成1+2;3+4;5+6三个部分进行子程序进行计算后合并。

    四、源码解读

    1、leftTask.fork();

    public final ForkJoinTask<V> fork() {
         Thread t;
         if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
             ((ForkJoinWorkerThread)t).workQueue.push(this);
         else
             ForkJoinPool.common.externalPush(this);
         return this;
    }

    fork方法内部会先判断当前线程是否是ForkJoinWorkerThread的实例,如果满足条件,则将task任务push到当前线程所维护的双端队列中。

    final void push(ForkJoinTask<?> task) {
                ForkJoinTask<?>[] a; ForkJoinPool p;
                int b = base, s = top, n;
                if ((a = array) != null) {    // ignore if queue removed
                    int m = a.length - 1;     // fenced write for task visibility
                    U.putOrderedObject(a, ((m & s) << ASHIFT) + ABASE, task);
                    U.putOrderedInt(this, QTOP, s + 1);
                    if ((n = s - b) <= 1) {
                        if ((p = pool) != null)
                            p.signalWork(p.workQueues, this);
                    }
                    else if (n >= m)
                        growArray();
                }
            }

    在push方法中,会调用ForkJoinPool的signalWork方法唤醒或创建一个工作线程来异步执行该task任务。

    2、

     public final V join() {
            int s;
            if ((s = doJoin() & DONE_MASK) != NORMAL)
                reportException(s);
            return getRawResult();
        }

    通过doJoin方法返回的任务状态来判断,如果不是NORMAL,则抛异常:

     private void reportException(int s) {
            if (s == CANCELLED)
                throw new CancellationException();
            if (s == EXCEPTIONAL)
                rethrow(getThrowableException());
        }

    来看下doJoin方法:

    private int doJoin() {
            int s; Thread t; ForkJoinWorkerThread wt; ForkJoinPool.WorkQueue w;
            return (s = status) < 0 ? s :
                ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) ?
                (w = (wt = (ForkJoinWorkerThread)t).workQueue).
                tryUnpush(this) && (s = doExec()) < 0 ? s :
                wt.pool.awaitJoin(w, this, 0L) :
                externalAwaitDone();
        }

    先查看任务状态,如果已经完成,则直接返回任务状态;如果没有完成,则从任务队列中取出任务并执行。

  • 相关阅读:
    为什么Java不支持多重继承
    thymeleaf生成页面时报错:An error happened during template parsing (template: "class path resource [templates/index.html]")的解决办法
    MySQL操作数据时区分大小写
    java.lang.NoClassDefFoundError: com/jhlabs/image/RippleFilter
    多线程学习系列:(六)线程池基础下
    多线程学习系列:(四)线程同步基础下
    多线程学习系列:(八)Winform中多线程编程基础上
    多线程学习系列:(五)线程池基础上
    多线程学习系列:(七)基于多线程的基本组件
    HTTP头部
  • 原文地址:https://www.cnblogs.com/x-jingxin/p/10687750.html
Copyright © 2011-2022 走看看