工作窃取算法

一个大任务拆分成多个小任务，为了减少线程间的竞争，把这些子任务分别放到不同的队列中，并且每个队列都有单独的线程来执行队列里的任务，线程和队列一一对应。

但是会出现这样一种情况：A线程处理完了自己队列的任务，B线程的队列里还有很多任务要处理。

A是一个很热情的线程，想过去帮忙，但是如果两个线程访问同一个队列，会产生竞争，所以A想了一个办法，从双端队列的尾部拿任务执行。而B线程永远是从双端队列的头部拿任务执行。

 

注意：线程池中的每个线程都有自己的工作队列（PS，这一点和ThreadPoolExecutor不同，ThreadPoolExecutor是所有线程公用一个工作队列，所有线程都从这个工作队列中取任务），当自己队列中的任务都完成以后，会从其它线程的工作队列中偷一个任务执行，这样可以充分利用资源。

工作窃取算法的优点：

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

工作窃取算法的缺点：

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

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

3.主要类

1. ForkJoinTask：

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

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

1. ForkJoinPool：

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

1. ForkJoinWorkerThread：

ForkJoinPool线程池中的一个执行任务的线程。

Future 用来接受多线程池的结果

fork：起到将任务继续递归的作用

join：起到计算结果的作用

package pool;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

/*
   1+2+3+...+100
 */
public class SumTask2 extends RecursiveTask<Long> {
    int start;
    int end;
    int step=1000;

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

    public int getStart() {
        return start;
    }

    public void setStart(int start) {
        this.start = start;
    }

    public int getEnd() {
        return end;
    }

    public void setEnd(int end) {
        this.end = end;
    }


    @Override
    protected Long compute() {
        //定义一个结果变量sum
        long sum=0;
        //计算结果
        if (end - start <= step) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        }else{//分解任务
            int mid = (start + end) / 2;
            SumTask2 leftTask = new SumTask2(start,mid);
            SumTask2 rightTask = new SumTask2(mid+1, end);
            //继续分解
            leftTask.fork();
            rightTask.fork();

            //结果求和
            long leftSum = leftTask.join();
            long rightSum = rightTask.join();
             sum = leftSum + rightSum;

        }

        //返回结果
        return sum;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //使用循环求和
        //计算机有四个核，只有一个核参与任务
        int n=1000000000;
        long sum=0;
        long startTime = System.currentTimeMillis();
        for (int i = 0; i <= n; i++) {
            sum = sum + i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("for loop:" + sum + ",time=" + (endTime - startTime));
        //使用fork join求和
        //创建一个forkjoin线程池
        long startTime1 = System.currentTimeMillis();
        ForkJoinPool pool = new ForkJoinPool();
        //给出一个任务
        RecursiveTask task = new SumTask2(1,n);

        //将任务交给线程池(线程池会分解任务并合并结果)
        Future<Long> future = pool.submit(task);
        //获取结果
        long result = future.get();
        long endTime1 = System.currentTimeMillis();

        System.out.println("forkjoin:"+result+ ",time=" + (endTime1 - startTime1));
        //关闭forkjoin线程池
        pool.shutdown();

    }

}