ThreadPoolExecutor

最新推荐文章于 2025-11-17 01:13:33 发布

原创最新推荐文章于 2025-11-17 01:13:33 发布 · 482 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线程池

java 专栏收录该内容

4 篇文章

订阅专栏

本文深入解析了ThreadPoolExecutor的构造方法及参数意义，包括核心线程数、最大线程数、线程空闲时间、时间单位、任务队列、线程工厂和拒绝策略。并通过实例展示了如何创建和使用线程池。

ThreadPoolExecutor 创建线程池

 public ThreadPoolExecutor(int corePoolSize, // 1
                              int maximumPoolSize,  // 2
                              long keepAliveTime,  // 3
                              TimeUnit unit,  // 4
                              BlockingQueue<Runnable> workQueue, // 5
                              ThreadFactory threadFactory,  // 6
                              RejectedExecutionHandler handler ) { //7
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

序号	名称	类型	含义
1	corePoolSize	int	核心线程池大小
2	maximumPoolSize	int	最大线程池大小
3	keepAliveTime	long	线程最大空闲时间
4	unit	TimeUnit	时间单位
5	workQueue	BlockingQueue	线程等待队列
6	threadFactory	ThreadFactory	线程创建工厂
7	handler	RejectedExecutionHandler	拒绝策略

corePoolSize与maximumPoolSize相等，即其线程全为核心线程，是一个固定大小的线程池，是其优势；
keepAliveTime = 0 该参数默认对核心线程无效，而FixedThreadPool全部为核心线程；
workQueue 为LinkedBlockingQueue（无界阻塞队列），队列最大值为Integer.MAX_VALUE。如果任务提交速度持续大余任务处理速度，会造成队列大量阻塞。因为队列很大，很有可能在拒绝策略前，内存溢出。是其劣势；
FixedThreadPool的任务执行是无序的；

package com.zkl;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created by ${ZKL} on 2019/3/14.
 */
public class ThreadPool {
    ThreadPoolExecutor threadPoolExecutor = null;
    public void init() {

        threadPoolExecutor = new ThreadPoolExecutor(5, 10, 10,
                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(50),new ThreadPoolExecutor.CallerRunsPolicy());
    }
    public void destory() {
        if (threadPoolExecutor != null) {
            threadPoolExecutor.shutdown();
        }
    }
     public ThreadPoolExecutor getPoll() {
        if (threadPoolExecutor != null) {
           return   this.threadPoolExecutor=threadPoolExecutor;
        }else {
            return null;
        }

    }

    public static void main(String[] args) {
        ThreadPool pool = new ThreadPool();
        pool.init();
        for (int i = 1; i < 100; i++) {
            System.out.println("提交第" + i + "个任务!");
            pool.getPoll().execute(new Runnable() {
                @Override
                public void run() {
                try {
                    	System.out.println(">>>task is running=====");
                        TimeUnit.SECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

        }
       pool.destory();
    }

}