前端 javascript jquery 异步线程池、异步执行器

package org.example.thread;

public class Test {

public static void main(String[] args) {

AsyncProcessExecutor normalExecutor = AsyncProcessExecutorFactory.createNormalExecutor();

normalExecutor.put(() -> {

System.out.println("123");

test();

});

normalExecutor.execute();

System.out.println("00000000000000000000000000000");

}

private static void test(){

try {

Thread.sleep(1000);

System.out.println("test...............");

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

线程池代码

package org.example.thread;

/**

* 异步进程 执行器

*

* @date 2021年7月15日13:43:37

*/

public interface AsyncProcessExecutor {

/**

* 存放任务

*

* @param task 任务

* @return AsyncProcessExecutor

*/

AsyncProcessExecutor put(final Runnable task);

/**

* 执行

*

* @return boolean

*/

boolean execute();

}

package org.example.thread;

import cn.hutool.core.collection.CollUtil;

import com.google.common.collect.Maps;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

/**

* 多线程锁执行器 正常处理

*

* @date 2020-12-10 10:36

*/

@Slf4j

public class AsyncProcessExecutorByNormal implements AsyncProcessExecutor {

/**

* 线程池字典

*/

private static final Map EXECUTOR_MAP = Maps.newConcurrentMap();

/**

* 线程Key

*/

private final String key;

/**

* 任务队列

*/

private final List taskList;

/**

* 执行器

*/

private final AsyncProcessor processor;

/**

* 构造函数

*/

public AsyncProcessExecutorByNormal() {

this.key = "def";

taskList = new ArrayList<>();

processor = AsyncProcessExecutorByNormal.getProcessor(this.key);

}

/**

* 构造函数

*

* @param key 线程池唯一Key

*/

public AsyncProcessExecutorByNormal(String key) {

this.key = key;

taskList = new ArrayList<>();

processor = AsyncProcessExecutorByNormal.getProcessor(this.key);

}

/**

* 获得执行器

*

* @param key Key

* @return AsyncProcessor

*/

private synchronized static AsyncProcessor getProcessor(String key) {

AsyncProcessor asyncProcessor = EXECUTOR_MAP.get(key);

if (null == asyncProcessor) {

asyncProcessor = new AsyncProcessor();

asyncProcessor.init(key);

EXECUTOR_MAP.put(key, asyncProcessor);

}

return asyncProcessor;

}

/**

* 执行

*

* @param task 任务

*/

@Override

public AsyncProcessExecutorByNormal put(final Runnable task) {

taskList.add(task);

return this;

}

// ====================================

/**

* 执行 线程锁 等待查询结果 结果完成后继续执行

*

* @return boolean 最终直接结果

*/

@Override

public boolean execute() {

if (CollUtil.isEmpty(this.taskList)) {

return true;

}

for (Runnable task : this.taskList) {

// 多线程执行任务

this.execute(task);

}

// 返回执行结果

return true;

}

/**

* 执行指定的任务

*

* @param task 任务

* @return boolean

*/

private boolean execute(final Runnable task) {

return processor.executeTask(task);

}

}

package org.example.thread;

import cn.hutool.core.collection.CollUtil;

import com.google.common.collect.Maps;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.concurrent.Callable;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.Executors;

import java.util.concurrent.atomic.AtomicInteger;

/**

* 多线程锁执行器

* 用于当前方法中复杂业务多线程处理，等待线程执行完毕后 获得统一结果

* 2021年11月2日14:07:54 重构 多线程异步等待执行器

*

* @author 周鹏程

* @date 2020-12-10 10:36

*/

@Slf4j

public class AsyncProcessExecutorByWait implements AsyncProcessExecutor {

/**

* 线程池字典

*/

private static final Map EXECUTOR_MAP = Maps.newConcurrentMap();

/**

* 线程Key

*/

private final String key;

/**

* 任务队列

*/

private final List> taskList;

/**

* 执行器

*/

private final AsyncProcessor processor;

/**

* 任务执行计数器

*/

private AtomicInteger count;

/**

* 构造函数

*/

public AsyncProcessExecutorByWait() {

this.key = "def";

taskList = new ArrayList<>();

processor = getProcessor(this.key);

}

/**

* 构造函数

*

* @param key 线程池唯一Key

*/

public AsyncProcessExecutorByWait(String key) {

this.key = key;

taskList = new ArrayList<>();

processor = getProcessor(this.key);

}

/**

* 获得执行器

*

* @param key Key

* @return AsyncProcessor

*/

private synchronized static AsyncProcessor getProcessor(String key) {

AsyncProcessor asyncProcessor = EXECUTOR_MAP.get(key);

if (null == asyncProcessor) {

asyncProcessor = new AsyncProcessor();

asyncProcessor.init(key);

EXECUTOR_MAP.put(key, asyncProcessor);

}

return asyncProcessor;

}

/**

* 放入执行任务

* 特殊处理 Runnable 转换为 Callable

*

* @param task 任务

*/

@Override

public AsyncProcessExecutor put(final Runnable task) {

taskList.add(Executors.callable(task));

return this;

}

/**

* 执行 线程锁 等待查询结果 结果完成后继续执行

*/

@Override

public boolean execute() {

if (CollUtil.isEmpty(this.taskList)) {

return true;

}

// 初始化锁参数

count = new AtomicInteger(this.taskList.size());

// 门闩 线程锁

CountDownLatch latch = new CountDownLatch(this.taskList.size());

for (Callable