java for循环改造多线程-线程池原理

通过ThreadPoolExecutor类自定义:

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        // 省略...
    }

1、共7个参数如下：

（1）corePoolSize：核心线程数，线程池中始终存活的线程数。

（2）maximumPoolSize: 最大线程数，线程池中允许的最大线程数。

（3）keepAliveTime: 存活时间，线程没有任务执行时最多保持多久时间会终止。

（4）unit: 单位，参数keepAliveTime的时间单位，7种可选。

（5）workQueue: 一个阻塞队列，用来存储等待执行的任务，均为线程安全，7种可选。

较常用的是LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

（6）threadFactory: 线程工厂，主要用来创建线程，默及正常优先级、非守护线程。

（7）handler：拒绝策略，拒绝处理任务时的策略，4种可选，默认为AbortPolicy。

2、顺便说下线程池的执行规则如下：

（1）当线程数小于核心线程数时，创建线程。

（2）当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。

（3）当线程数大于等于核心线程数，且任务队列已满：

若线程数小于最大线程数，创建线程。

若线程数等于最大线程数，抛出异常，拒绝任务。

示例代码：

package com.company;

import java.time.LocalDateTime;
import java.util.concurrent.*;

public class Main {

    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(5, 20,
                1, TimeUnit.MINUTES, new ArrayBlockingQueue<>(100, true),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
            final int index = i;
            executorService.execute(() -> {
                // 获取线程名称,默认格式:pool-1-thread-1
                System.out.println(LocalDateTime.now() + " " + Thread.currentThread().getName() + " " + index);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}