写了一个多线程的通用调用方法，只需要传入请求参数List和调用的方法即可通过多线程得到返回结果list，

适用于同一个方法被调用多次的情况。

1：首先创建一个接口

@FunctionalInterface

public interface MyFunction {

R doFunction(T t);

}

2:创建一个实现类

public class AsyncFunctionImpl {

public static List asyncFunction(List inputList, MyFunction function)

{

// 创建一个线程大小与集合数量相等的线程池

ExecutorService pool = Executors.newFixedThreadPool(inputList.size());

// 创建Future的list集合，用以接收返回值

List list = new ArrayList();

for (int i = 0; i < inputList.size(); i++) {

// 执行任务并获取Future对象，这里采用lambda表达式替代Callable接口的实现

// getName(input)就是你要执行业务逻辑的方法，返回值需要用f.get()获取

int finalI = i;

Future f = pool.submit(() -> function.doFunction(inputList.get(finalI)));

list.add(f);

}

// 关闭线程池

pool.shutdown();

// 循环获取所有并发线程的任务结果

//FAKE_ROUND_WAY

List outputList = new ArrayList<>();

for (Future f : list) {

// 从Future对象上获取任务的返回值，返回一个实体类,需要进行强制转换

//f.get()会一直阻塞主进程，直到业务逻辑方法执行结束

try {

outputList.add((R)f.get());

} catch (InterruptedException e) {

throw new ApiException(e.getMessage());

} catch (ExecutionException e) {

throw new ApiException(e.getMessage());

}

}

return outputList;

}

}

3:调用

public static void main(String[] args) {

List inputList = new ArrayList<>();

//首先我们构造一个请求参数的集合

for (int i = 0; i < 50; i++) {

Input input = new Input();

input.setNameInput("第" + i + "次请求");

inputList.add(input);

}

//开启多线程调用方法

List outputList = AsyncFunctionImpl.asyncFunction(inputList, (x) -> getName(x));

outputList.forEach(p-> System.out.println(p.getNameOutput()));

}

/**

* 请求实体类

*/

public static class Input {

private String nameInput;

public String getNameInput() {

return nameInput;

}

public void setNameInput(String nameInput) {

this.nameInput = nameInput;

}

}

/**

* 返回实体类

*/

public static class Output {

private String nameOutput;

public String getNameOutput() {

return nameOutput;

}

public void setNameOutput(String nameOutput) {

this.nameOutput = nameOutput;

}

}

/**

* 你的业务逻辑方法

*

* @param input 请求实体类参数

* @return 返回实体类参数

*/

public static Output getName(Input input) {

//为了证明我们的确开启了多线程，所以此处加了沉睡1秒钟的操作，50次循环在5秒钟内执行完毕，证明的确开启了多线程

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

Output output = new Output();

//方法执行逻辑,我们这里只是将请求参数的nameInput赋值给返回参数的nameOutput

output.setNameOutput(input.getNameInput()+",返回结果赋值");

//返回

return output;

}