线程池的创建使用

Executors创建线程池

newFixedThreadPool的阻塞队列大小是没有大小限制的，如果队列堆积数据太多会造成资源消耗。
newCachedThreadPool是线程数量是没有大小限制的，当新的线程来了直接创建，同样会造成资源消耗殆尽。

   ExecutorService executor = Executors.newFixedThreadPool(1);
        CompletableFuture<String> future = CompletableFuture.supplyAsync( new Supplier<String>() {
            @SneakyThrows
            @Override
            public String get() {
                log.info(" resourceCategory is 2 , save order_resource_rt started!");
               Thread.sleep( 3000l );
                try {
                 //逻辑代码
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return "save order_resource_rt ["+num+"]  finished!";
            }
        }, executor);

        //回调
        future.thenAccept(e -> log.info(e + " ok"));

ThreadPoolExecutor创建线程池（推荐）

在新建线程池的时候使用ThreadPoolExecutor创建，阻塞队列可以使用ArrayBlockingQueue,这个队列的源码很金典，锁是一个成员变量。

开发中常用util

public class ThreadExecutorUtil {
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
            namePrefix = "cdb-c-" + poolNumber.getAndIncrement();
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

    private static final Logger log = LoggerFactory.getLogger(ThreadExecutorUtil.class);
    private int maxThreadNum = 10;
    
    private ThreadPoolExecutor executor = new ThreadPoolExecutor(
            this.maxThreadNum / 2 > 0 ? this.maxThreadNum / 2 : 1, //线程池默认线程数
            this.maxThreadNum, //最大同时线程数
            60L, //线程池维护线程所允许的空闲时间
            TimeUnit.SECONDS, 
            new ArrayBlockingQueue<Runnable>(32), //线程池所使用的缓冲队列 
            new DefaultThreadFactory(), 
            new ThreadPoolExecutor.CallerRunsPolicy()) {
        protected void afterExecute(Runnable r, Throwable t) {
            super.afterExecute(r, t);
            if (t != null) {
                log.error("线程池内任务出错：", t);
            }
        }
    };
    
    private static ThreadExecutorUtil instance = new ThreadExecutorUtil();
    
    private ThreadExecutorUtil() {   
    }

    public static void execute(Runnable runnable) {
        log.debug("Active thread:" + instance.executor.getActiveCount() 
                + ",wait threads:" + instance.executor.getQueue().size()
                + ",largest wait:" + instance.executor.getLargestPoolSize()
                + ",complete:" + instance.executor.getCompletedTaskCount());
        instance.executor.execute(runnable);
    }
}

调用代码

ThreadExecutorUtil.execute(new Runnable() {

		                @Override
		                public void run() {
		                   	System.out.println("我是子线程");
		                }
		            });