博客

在开发的过程中，我们很多的场景都需要使用了多线程来进行操作，有些需要返回处理结果，有些不需要，直接进行操作，为了防止项目中出现多个线程池的定义，导致代码较为混乱，本次基于目的进行多线程工具类的封装。

一：定义工具类

public class TaskUtil {

    private static ThreadPoolExecutor executors = null;

    private static ThreadPoolExecutor syncExecutors = null;

    private static final Logger logger = LoggerFactory.getLogger(TaskUtil.class);


    static {
        int threadSize = 20;
        executors = new ThreadPoolExecutor(threadSize, threadSize,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(1000));

        syncExecutors = new ThreadPoolExecutor(60, 60,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(1000));
    }

    /**
     * 多线程异步处理任务
     *
     * @param task
     */
    public static void run(Runnable task) {
        try {
            executors.execute(task);
        } catch (Exception e) {
            logger.error("", e);
        }
    }

    /**
     * 执行操作，并获取执行结果
     *
     * @param
     * @param
     * @param
     * @param
     * @return
     */
    public static String taskWithResult(String name) {


        try {
            CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
                try {
                    logger.info("开始" + name);
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return name;
            }, syncExecutors);
            cf1.join();
        } catch (Exception e) {
            logger.error("taskWithResult 任务执行失败", e);
            return null;
        }

        return name;
    }


}

我们使用ThreadPoolExecutor来自定义的创建线程池，分别疯转了无返回值和有返回值两种

开始样例测试

二：接口类

public interface taskService {

    void taskServiceMsg(String name);

    String taskWithResult(String name);
}

三：定义接口使用类

@Service
public class taskServiceImpl implements taskService {

    public static List<String> list = new ArrayList<>();

    private static final Logger logger = LoggerFactory.getLogger(TaskUtil.class);

    @Override
    public void taskServiceMsg(String name) {
        TaskUtil.run(() -> {
            if (!StringUtil.isNullOrEmpty(name)) {
                try {
                    logger.info("开始执行" + name);
                    Thread.sleep(2000);
                    list.add(name);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }


            }
        });
    }

    @Override
    public String taskWithResult(String name) {

        String result = TaskUtil.taskWithResult(name);

        return result;
    }

四：调用类编写

    @ResponseBody
    @RequestMapping("3")
    public List<String> test3() {

        for (int i = 0; i < 100; i++) {
            task.taskServiceMsg("text" + i);
        }
        return taskServiceImpl.list;
//        return "异步执行";
    }

    @ResponseBody
    @RequestMapping("4")
    public String test4() {

        String result = "";
        final int k = 0;
        for (int i = 0; i < 10000; i++) {

            result = task.taskWithResult("name" + i);
        }
        return result;
    }

测试结果：

本次只是做了一些简单的测试，业务的逻辑需要业务方各自根据自己的业务需求进行改造，但思路都基本不变。