java线程池生成线程的时机

java线程池生成线程的时机

直接上结论：
1.当前线程数<核心线程数时，进来1个任务即生成一个核心线程。
2.线程数达到核心线程数，但阻塞队列没有满，线程数不变。
3.阻塞队列满了，每进来1个任务便生成1个线程，但不会超过最大线程。
4.当前线程数=最大线程数，阻塞队列也满了，那么新来的任务将进入抛弃策略。

验证环节

示例代码块

public class MyThreadPoolExecutorTest {

    private static AtomicInteger nextId = new AtomicInteger(0);
    private static AtomicInteger abandonId = new AtomicInteger(0);
    
    private static int coreSize = 3;
    private static int maxSize = 10;
    private static int aliveTime = 10;
    private static int queueCapacity = 100;
    private static int taskCount = 1000;

    public static void main(String[] args) {
        ThreadPoolExecutor mThreadPool = new ThreadPoolExecutor(coreSize, maxSize, aliveTime, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueCapacity),
                //线程工厂
                (task) -> {
                    String name = "MyThread-" + nextId.getAndIncrement();
                    Thread thread = new Thread(null, task, name, 0);
                    System.out.println(thread.getName());
                    return thread;
                },
                //抛弃策略
                (task, executor) -> {
                    abandonId.getAndIncrement();
                    //System.out.println("abandon！");
                });
        for (int i = 0; i < taskCount; i++) {
            mThreadPool.execute(() -> {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        System.out.println("abandon:" + abandonId.get());
        mThreadPool.shutdown();
    }
}

1.当前线程数<核心线程数时，进来1个任务即生成一个核心线程。

参数设置：
private static int coreSize = 3;
private static int maxSize = 10;
private static int aliveTime = 10;
private static int queueCapacity = 100;
private static int taskCount = 2;

结果：
MyThread-0
MyThread-1
abandon:0

2.线程数达到核心线程数，但阻塞队列没有满，线程数不变。

参数设置：
private static int coreSize = 3;
private static int maxSize = 10;
private static int aliveTime = 10;
private static int queueCapacity = 1000;
private static int taskCount = 1000;

结果：
MyThread-0
MyThread-1
MyThread-2
abandon:0

注：1000(阻塞队列数)+3(核心线程数)>1000(任务数)

3.阻塞队列满了，每进来1个任务便生成1个线程，但不会超过最大线程。

参数设置：
private static int coreSize = 3;
private static int maxSize = 10;
private static int aliveTime = 10;
private static int queueCapacity = 6;
private static int taskCount = 10;

结果：
MyThread-0
MyThread-1
MyThread-2
MyThread-3
abandon:0

注：此处10-6-3=1，所以会出现第四个线程。但是如果机器性能比较差，可能运行到此处时前面已经有任务完成了，核心线程多接管了1个任务，便不会生成新线程。

4.当前线程数=最大线程数，阻塞队列也满了，那么新来的任务将进入抛弃策略

参数设置：
private static int coreSize = 3;
private static int maxSize = 10;
private static int aliveTime = 10;
private static int queueCapacity = 100;
private static int taskCount = 1000;

结果：
MyThread-0
MyThread-1
MyThread-2
MyThread-3
MyThread-4
MyThread-5
MyThread-6
MyThread-7
MyThread-8
MyThread-9
abandon:890

注：1000-10(最大线程数)-100(阻塞队列里存储100个任务)=890。但是如果机器性能比较差，可能运行到此处时前面已经有任务完成了，线程多接管了任务，便可能小于此值。