线程池的入门级学习教程

线程池关系解析

public interface ExecutorService extends Executor {
    ...
}

public abstract class AbstractExecutorService implements ExecutorService {
    ...
}

public class ThreadPoolExecutor extends AbstractExecutorService {
    ...
}

创建一个线程池

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

各个参数的意义：

        corePoolSize ：池中一直保持的线程的数量， 即使线程空闲。

        maximumPoolSize：池中允许的最大的线程数。

        keepAliveTime：当线程数大于核心线程数的时候， 线程在最大多长时间没有接到新任务就会终止释放，最终线程池维持在 corePoolSize 大小。

         unit：时间单位

        workQueue：阻塞队列， 用来存储等待执行的任务， 如果当前对线程的需求超过了corePoolSize大小， 就会放在这里等待空闲线程执行。

        handler ：拒绝策略， 如果线程满了， 线程池就会使用拒绝策略

以下为代码中的具体创建方法：

@EnableConfigurationProperties(ThreadPoolConfigProperties.class)
@Configuration
public class MyThreadConfig {
    @Bean
    public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties pool) {
        return new ThreadPoolExecutor(
                pool.getCoreSize(),
                pool.getMaxSize(),
                pool.getKeepAliveTime(),
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(100000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
    }

@ConfigurationProperties(prefix = "xxx.xxx")
public class ThreadPoolConfigProperties {

    private Integer coreSize;

    private Integer maxSize;

    private Integer keepAliveTime;


        public Integer getCoreSize() {
        return coreSize;
    }

    public void setCoreSize(Integer coreSize) {
        this.coreSize = coreSize;
    }

    public Integer getMaxSize() {
        return maxSize;
    }

    public void setMaxSize(Integer maxSize) {
        this.maxSize = maxSize;
    }

    public Integer getKeepAliveTime() {
        return keepAliveTime;
    }

    public void setKeepAliveTime(Integer keepAliveTime) {
        this.keepAliveTime = keepAliveTime;
    }

    @Override
    public String toString() {
        return "ThreadPoolConfigProperties{" +
                "coreSize=" + coreSize +
                ", maxSize=" + maxSize +
                ", keepAliveTime=" + keepAliveTime +
                '}';
    }
}

运行流程：

1、 线程池创建， 准备好 corePoolSize 数量的核心线程， 准备接受任务。
2、 新的任务进来， 用 corePoolSize 准备好的空闲线程执行。
        (1) corePoolSize 满了， 就将再进来的任务放入阻塞队列workQueue中。 空闲的 corePoolSize 就会自己去阻塞队列获取任务执行。
        (2) 阻塞队列满了， 就直接开新线程执行， 最大只能开到 maximumPoolSize指定的数量
        (3)  maximumPoolSize都执行好了。 maximumPoolSize 数量空闲的线程会在 keepAliveTime 指定的时间后自动销毁。 最终保持到 corePoolSize 大小
        (4)  如果线程数开到了 maximumPoolSize 的数量， 还有新任务进来， 就会使用 reject 指定的拒绝策略进行处理。
3、 所有的线程创建都是由指定的 factory 创建的。