java多任务并发处理--Callable<?>

在我的工作中，使用多线程的目的只要在于：1、效率大大提升，2、内存能够有效控制，3、代码层次感分明</span>

    

目前来说，我主要熟知的为以下两种：

一、实现callable的线程，使用ExecutorService executor = Executors.newFixedThreadPool(5);线程池进行并发执行，

具体demo如下：

package com.ziglar.call;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Main
{

    public static void main(String[] args)
    {

        //模拟需要并发的参数 也有可能是对象集合，String可以使用其他任意对象（包含集合对象）进行替换
        List<String> params = new ArrayList<String>();
        params.add("first");
        params.add("Second");
        params.add("Third");
        params.add("Forth");

        //线程池，可以为固定大小，也可以使用Executors.newCachedThreadPool()根据环境自动创建合适的大小池

        ExecutorService executor = Executors.newFixedThreadPool(5);

        //将线程加入到集合中
        List<Callable<String>> list = new ArrayList<Callable<String>>();
        for (String param : params)
        {
            list.add(new Job(param));
        }
        try
        {
            //线程池加载线程
            List<Future<String>> futures = executor.invokeAll(list);

            //获取每个线程返回的结果，可以进行合并，作为多并发的结果
            for (Future<String> future : futures)
            {
                String result = future.get();
                System.out.println(result);
            }

        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        catch (ExecutionException e)
        {
            e.printStackTrace();
        }

    }
}

package com.ziglar.call;

import javax.xml.bind.SchemaOutputResolver;
import java.util.concurrent.Callable;

/**
 * Created by Administrator on 2016/6/30.
 */
public class Job implements Callable<String>
{
    private String name;

    private String jobName;
    public Job(String name)
    {
        this.name=name;
    }

    @Override
    public String call() throws Exception
    {
        this.jobName = Thread.currentThread().getName();
        //使用传入的参数执行一些其他的操作，比如对数据库进行操作
        return "单钱线程为：" + jobName +",传入的参数为："+ name;
    }
}

这种方式我在使用的时候，由于传入的参数对象层次比较多，所以进行3层并发嵌套，在子job中，再次使用类似父线程的方式，再开多并发。

并发的池都为5，主要考虑到实际的参数集合分解之后也都是5个左右，实际上运行参数数量多一点也影响不大。

二、继承RecursiveTask的线程，使用ForkJoinPool forkJoinPool =newForkJoinPool();这种能够将集合进行细分的并发。

(待补充)