高并发之多线程获取数据

开发中需要统计多个数据，或者获取大量数据进行计算，单线程获取速度过慢，因此采用多线程方案

创建线程有几种方式：Thread,Runnable,Callable,使用Executor框架来创建线程池

因为最终还要获取结果进行计算，于是采用了Executor框架

执行任务后通过future获取多线程的结果，最终的时间取决于最慢的那个线程

直接上代码

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

public class DemonTest {
    public static void main(String[] args)
    {
        DemonTest demonTest=new DemonTest();
        demonTest.test();
    }
    public void test()
    {
        List<String> list=new ArrayList<>();
        try {
            long start = System.currentTimeMillis();
            List<Callable<Map>> tasks = new ArrayList<>();
            for(int i=0;i<100;i++)
            {
                Callable<Map> callable = new TestCallable(String.valueOf(i));
                tasks.add(callable);
            }
            //定义线程池
            ExecutorService executorService = Executors.newFixedThreadPool(10);
            //Future获取结果
            List<Future<Map>> futures=executorService.invokeAll(tasks,5, TimeUnit.SECONDS);//15S未返回，停止
            if(futures!=null&&futures.size()>0){
                for (Future<Map> future:futures){
                    if(future.isCancelled())
                    {
                        break;
                    }
                    Map map = future.get();//获取线程返回数据
                    list.add(map.get("data").toString());
                }
            }
            executorService.shutdown();//关闭线程池
            long end = System.currentTimeMillis();
            System.out.println("用时:"+(end-start)+"ms");
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
        for(int i=0;i<list.size();i++)
        {
            System.out.print(list.get(i)+",");
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class TestCallable implements Callable<Map> {
    private String servece;//可以传查询参数，或者传service实列
    private Map map;//返回数据
    public TestCallable(String  servece)
    {
        this.servece=servece;
    }
    @Override
    public Map call() throws Exception {
        //返回数据给Future
        System.out.println("执行任务"+servece);//获取参数，此类注解service会报错，也可以通过参数方式传过来
        map=new HashMap();
        map.put("data",servece);
        Thread.sleep(2000);
        return map;
    }
}

注意：任务数与futures是对应的，有100个Callable就有100个future，方法invokeAll根据设置的线程池数据10，那么同时执行10个线程去做任务，当设置超时时间后，如果在此时间没有执行完成，那么中断后续任务，此时futures依然是对应的100个，但是后续的任务没有返回数据，因此需要加判断，看任务是否取消。

 不判断future.isCancelled()并跳出循环，则会报异常，并且阻塞