hutool工具类-多线程

hutool工具类线程 - 自测记录

import cn.hutool.core.thread.ThreadFactoryBuilder;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.json.JSONUtil;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * hutool工具类线程测试
 */
public class ThreadTest {

    /**
     * 初始化线程池，同时执行2个线程
     */
    private static ExecutorService executor = ThreadUtil.newExecutor(2);

    public  static void main(String[] args) {
        final CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        Vector<Object> linkedList = new Vector<>();
        for ( int i = 0; i < list.size(); i++) {
            int t = i;
            executor.execute(() ->
                    {
                        //业务处理
                        String s = list.get(t);
                        linkedList.add(s+"---=");
                        System.out.println(s);              
                    }
                    );
        }
        executor.shutdown();
        System.out.println(JSONUtil.toJsonStr(linkedList));
    }

//===其他测试=================
    public static void mainPoolExecutor() throws InterruptedException {
        //线程池设置名称
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNamePrefix("cyf-").build();
        //线程数,线程池中的最大线程数,空闲存活时间,参数keepAliveTime的时间单位,阻塞队列
        ExecutorService pool = new ThreadPoolExecutor(10, 200,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

        List<Integer> sum = Arrays.asList(1,2,3,4,5,6);
        List<Callable<Integer>> tasks = new ArrayList<>();
        long t = System.currentTimeMillis();
        for (int i : sum) {
            tasks.add(new TaskTest(i));
        }
        List<Future<Integer>> all = pool.invokeAll(tasks);
        all.stream()
                .forEach(
                        k -> {
                            try {
                                System.out.println(k.get());
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            } catch (ExecutionException e) {
                                e.printStackTrace();
                            }
                        });
        pool.shutdown();
        System.out.println("任务结束时间:"+(System.currentTimeMillis()-t));
    }

    private static class TaskTest implements Callable<Integer>{

        private Integer sum = 0;
        public TaskTest(int sum){
            this.sum = sum;
        }
        @Override
        public Integer call() throws Exception {
            System.out.println("任务开始执行："+Thread.currentThread().getName());
            Thread.sleep(1000);
            System.out.println("任务进入执行："+Thread.currentThread().getName());
            return sum+10;
        }
    }
}