多线程处理任务

在导出excel文件时，再有多个sheet页需要导出时，每个sheet页可以使用单个线程执行，那么多个sheet页就需要多个线程并行执行，提高执行效率，这是在工作中遇到的一个场景，所有用来记录一下多线程处理任务的做法。

简单的demo:
1.建立一个任务接口，定义一个任务方法

public interface Output {
    /**
     * 输出字符串
     * @return
     */
    String say();
}

2.实现多个不同的任务

public class A implements Output {

    @Override
    public String say() {
        return "A";
    }
}

public class B implements Output {
    @Override
    public String say() {
        return "B";
    }
}

public class C implements Output{
    @Override
    public String say() {
        return "C";
    }
}

3.多线程处理任务方法

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
public class ThreadExecute {

    public List<String> execute(List<Output> outputs) {
        System.out.println("主线程开始执行");
        List<Future<String>> futures = new ArrayList<>();//用来存放子线程执行任务的future结果集
        ExecutorService executorService = Executors.newFixedThreadPool(outputs.size());//创建一个线程个数为outputs.size()的线程池
        //以下for循环是创建子线程的过程
        for (Output output : outputs) {
            Callable<String> callable = new Callable() {
                @Override
                public String call() throws Exception {
                	if (output.getClass().getName().equals("com.test.thread.A")) {
                        //Thread.sleep(5000);//休眠子线程，模拟子线程执行时间很长的场景，用来做测试
                    }
                    System.out.println("当前子线程名称：" + Thread.currentThread().getName() + " " + output.getClass().getName());
                    return output.say();//调用任务方法
                }
            };//创建子线程
            Future<String> future = executorService.submit(callable);//执行子线程
            /*
            将子线程的执行结果添加结果集中，这一步是在主线程中执行的，在添加的时候，子线程可能还未执行完毕，
            不过不影响后续的使用，因为在从future中使用get()方法获取执行结果时，如果子线程还未执行完毕，会阻塞主线程，等待子线程执行完毕
            */
            futures.add(future);
        }
        /*
			shutdown() 用来关闭线程池
			1.线程池停止接受新的任务。
			2.如果有正在执行和等待的任务，会继续执行完成。
			3.直到第2步完成，才会真正停止
		*/
        executorService.shutdown();
        System.out.println(futures.size());
        List<String> result = new ArrayList<>();//存放从future中获取的结果
        for (Future<String> future : futures) {
            try {
            	/*
            	从future中使用get()方法获取执行结果时，如果子线程还未执行完毕，会阻塞主线程，等待子线程执行完毕
            	*/
                result.add(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.println(result);
        System.out.println("主线程执行完毕");
        return result;
    }
}

4.测试

public class TestThread {

    public static void main(String[] args) {
        List<Output> outputs = new ArrayList<>();
        outputs.add(new A());
        outputs.add(new B());
        outputs.add(new C());
        ThreadExecute execute = new ThreadExecute();
        execute.execute(outputs);
    }
}

结果如下：
正常情况：

当任务类名为“com.test.thread.A”时，子任务执行时间很长时（休眠5秒）：

注：
1.如果子线程不需要返回结果，子线程可使用Runable