Java并发编程从入门到精通

1、综述：化繁为简，分而治之；递归的分解和合并，直到任务小到可以接受的程度；
2、Future任务机制：
  Future接口就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果；必要时可以通过get方法获取执行结果，该方法会阻塞直到任务会返回结果；也就是说Future接口提供三种功能：判断任务是否完成、能够中断任务、能够获取任务执行结果；
  Future接口里面的常用方法；
3、FutureTask：
  FutureTask类是Future接口唯一的实现类；
  FutureTask类实现了Runnable接口和Future接口，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值；
  FutureTask的两个构造器；

/**
 * FutureTask的使用
 */
package thread06;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureTaskTest01
{
    public static void main(String[] args) throws InterruptedException, ExecutionException
    {
        MySon myson = new MySon("Thread Son1");
        FutureTask<String> ft1 = new FutureTask<String>(myson);
        new Thread(ft1).start();
        // 如果调用了get()方法，那么只有得到返回结果后才会继续往下面执行
        // 不调用get()方法（不想获取返回结果），直接继续往下走
        System.out.println(ft1.get());
        
        // 执行完指定线程，返回指定结果（22）
        FutureTask<Integer> ft2 = new FutureTask<Integer>(new MyRun(), 22);
        new Thread(ft2).start();
        System.out.println("result_" + ft2.get());
        
        System.out.println("Thread Main end!");
    }
}

class MySon implements Callable<String>
{
    private String name;
    
    public MySon(String name)
    {
        this.name = name;
    }
    
    @Override
    public String call() throws Exception
    {
        Thread.sleep(1000L);
        System.out.println(name + "任务计算完成");
        return "result_11";
    }
}

class MyRun implements Runnable
{
    @Override
    public void run()
    {
        try
        {
            Thread.sleep(1000L);  // 模拟干活
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        
        System.out.println("特定线程2完成任务");
    }
}

/*
任务实现Callable接口，可以返回结果；
任务实现Runnable接口，不可以返回结果，但可以通过FutureTask变相返回指定结果；
*/

4、Future使用场景：
  实际工作中，可能需要统计各种类型的报表呈现结果，可能一个大的报表需要依赖很多小的模块的运算结果，一个线程做可能又比较慢，就可以拆分成N多个小线程，然后将其结果合并起来作为大的报表呈现结果；接下来的Fork/Join就是基于Future实现的；
5、什么是Fork/Join框架：
  是一个用于并行执行任务的框架；是一个把大任务分割成若干个小任务执行，最终汇总每个小任务结果后得到大任务结果的框架；
6、Fork/Join的JDK里面的家族：
7、Fork/Join框架的实现原理：
8、异常处理机制和办法：
9、Fork/Join模式优缺点及其实际应用场景：
  优点：对于符合Fork/Join模式的应用，软件开发人员不再需要处理各种并行相关事务，例如同步、通信等，以难以调试而闻名的死锁和data race等错误也就不会出现，提升了思考问题的层次；并行分发策略，仅仅关注如何划分任务和组合中间结果，将剩下的事情丢给Fork/Join框架完成即可；
  缺点：如果拆分的对象过多时，小心一下子把内存撑满；等待线程的CPU资源释放了，但是线程对象等待时不会被垃圾机制回收；
  使用场景：对于树形结构类型的数据的处理和遍历非常合适；

/**
 * Fork/Join框架的使用：计算 1+2+3+4+5 的结果
 */
package thread06;

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

public class ForkJoinTest01
{
    public static void main(String[] args) throws InterruptedException, ExecutionException
    {
        ForkJoinPool pool = new ForkJoinPool();
        
        CountTask task1 = new CountTask(1, 5);
        Future<Integer> future = pool.submit(task1);
        System.out.println("1-5最终相加的结果为：" + future.get());
        
        CountTask task2 = new CountTask(1, 100);
        Future<Integer> future2 = pool.submit(task2);
        System.out.println("1-100最终相加的结果为：" + future2.get());
    }
}

class CountTask extends RecursiveTask<Integer>
{
    private static final long serialVersionUID = 1L;
    
    private static int splitSize = 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) <= splitSize;
        if(canCompute)
        {
            // 如果是 1+2+3 也是走这个分支
            for(int i=start;i<=end;i++)
            {
                sum = sum + i;
            }
        }
        else
        {
            // 拆分成两个子任务
            int middle = (start + end) / 2;
            CountTask firstTask = new CountTask(start, middle);
            CountTask secondTask = new CountTask(middle+1, end);
            
            // 子任务在调用fork方法时，又会进入compute方法，看看当前子任务是否需要继续分割成孙任务，
            // 如果不需要继续分割，则执行当前子任务并返回结果
            firstTask.fork();  // 开始计算
            secondTask.fork();
            
            // 获得第一个子任务的结果，得不到结果，此线程不会往下面执行
            int firstResult = firstTask.join();
            int secondResult = secondTask.join();
            
            // 合并两个儿子的执行结果
            sum = firstResult + secondResult;
        }
        
        return sum;
    }
    
}