JDK线程池详解

JDK多任务执行框架(线程池): 线程框架Executor
newFixedThreadPool() newCachedThreadPool() newSingleThreadPool() newScheduledThreadPool()

自定义线程池： ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit, BlockingQueue<Runnable>, ThreadFactory, RejectedExecutorHandler)
corePoolSize: 核心线程数，初始化时线程数
maximumPoolSize： 最大线程数
keepAliveTime：池中线程数大于core的个数时，空闲的线程销毁的时间
BlockingQueue： 提交的线程个数超过maximumPoolSize时，多余的线程缓冲的数据区域
ThreadFactory： 创建线程时的工厂
RejectedExecutorHandler： 当提交的线程数大于(maximumPoolSize + BlockingQueue的个数)时，提交的线程被拒绝所执行的程序

自定义线程池代码

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Test {

    public static void main(String[] args) {
        ThreadFactory factory = new MyThreadFactory();
        RejectedExecutionHandler handler = new MyRejectedExecutionHandler();
        ThreadPoolExecutor pool = new ThreadPoolExecutor(2, 10, 60L, TimeUnit.SECONDS
                , new ArrayBlockingQueue<Runnable>(10), factory, handler);
        // 需要提交的线程有30个，最大线程10个，阻塞队列10个，还有10个线程无法提交。
        for (int  i = 0; i < 30; i++) {
            Runnable r = new MyRunnable(i);
            pool.submit(r);
        }

        System.out.println(pool.getMaximumPoolSize());
    }
}


class MyRunnable implements Runnable {
    private int i;

    public MyRunnable (int i) {
        this.i = i;

    }
    @Override
    public void run() {
        try {
            Thread.sleep(10000); // 如果线程中的此处不阻塞，那么就会存在核心线程数处理完成后，直接进行下一个任务，即不会用到阻塞队列
            System.out.println(Thread.currentThread().getName() + " Run: [" + this.i + "]");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

class MyThreadFactory implements ThreadFactory {

    private Random random = new Random();

    @Override
    public Thread newThread(Runnable r) {
        String threadName = Integer.toString(random.nextInt(500));
        Thread thread = new Thread(r);
        thread.setName(threadName);
        System.out.println("MyThreadFactory -> newThread:" + threadName);
        return thread;
    }
}

class MyRejectedExecutionHandler implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("线程被拒绝:" + r.toString()); 
        // 通过动态增加线程池的最大线程数来满足所有线程
        executor.setMaximumPoolSize(executor.getMaximumPoolSize() + 1);
        executor.submit(r);
    }
}