深入理解Java ThreadPoolExecutor 构造器参数详解-优快云博客

本文链接：https://blog.youkuaiyun.com/tiger_root/article/details/126413228

本文解析了Java线程池ThreadPoolExecutor构造器中各个参数的含义，包括核心线程数、最大线程数、空闲线程存活时间、时间单位、任务队列类型、线程工厂和拒绝策略，帮助开发者更好地配置和使用线程池。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线程池构造器上参数的含义

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

- corePoolSize线程池的核心大小
- maximumPoolSize线程池中允许的最大线程数
- keepAliveTime存活时间间隔
- timeUnit时间单元
- workQueue阻塞任务队列
- threadFactory线程工厂
- RejectedExecutionHandler饱和处理策略

构造器中各个参数的含义：

corePoolSize 线程池中的核心线程数。当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize；如果当前线程数为corePoolSize，继续提交的任务被保存到阻塞队列中，等待被执行。
maximumPoolSize 线程池中允许的最大线程数。如果当前阻塞队列满了，且继续提交任务，则创建新的线程执行任务，前提是当前线程数小于maximumPoolSize。
keepAliveTime 线程空闲时的存活时间。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，keepAliveTime参数也会起作用，直到线程池中的线程数为0。
unit keepAliveTime参数的时间单位。例如TimeUnit.DAYS
workQueue 任务缓存队列，用来存放等待执行的任务。如果当前线程数为corePoolSize，继续提交的任务就会被保存到任务缓存队列中，等待被执行。一般来说，这里的BlockingQueue阻塞队列有以下三种选择： -SynchronousQueue：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态。因此，如果线程池中始终没有空闲线程（任务提交的平均速度快于被处理的速度），可能出现无限制的线程增长。 - LinkedBlockingQueue：基于链表结构的阻塞队列，如果不设置初始化容量，其容量Integer.MAX_VALUE，即为无界队列。因此，如果线程池中线程数达到了corePoolSize，且始终没有空闲线程（任务提交的平均速度快于被处理的速度），任务缓存队列可能出现无限制的增长。 - ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务。
threadFactory 线程工厂，创建新线程时使用的线程工厂。
handler 任务拒绝策略，当阻塞队列满了，且线程池中的线程数达到maximumPoolSize，如果继续提交任务，就会采取任务拒绝策略处理该任务，线程池提供了4种任务拒绝策略： - AbortPolicy：丢弃任务并抛出RejectedExecutionException异常，默认策略； - CallerRunsPolicy：由调用execute方法的线程执行该任务； - DiscardPolicy：丢弃任务，但是不抛出异常; - DiscardOldestPolicy：丢弃阻塞队列最前面的任务，然后重新尝试执行任务（重复此过程）。当然也可以根据应用场景实现RejectedExecutionHandler接口自定义饱和策略，如记录日志或持久化存储不能处理的任务。

public class Test41 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建线程池
		ExecutorService es=Executors.newCachedThreadPool();//newCachedThreadPool新建缓存线程池
		//提交任务到线程池中
		Future f=es.submit(()->{
			int sum=0;
			for(int i=0;i<=10;i++) {
				sum+=i;
			}
			return sum;
		});
		Object res=f.get();
		System.out.println(res);
	}
}

守护线程

正常情况下，非守护线程的执行时间和主线程无关，即使主线程已经结束，也不会影响子线程的运行。
守护线程是为其它线程提供服务的线程

守护进程的特点是当程序中主线程结束时，守护线程会自动中止
如何将一个子线程设置为守护线程

在一个线程调用start启动之前，调用方法thread.setDaemon(true);就可以将thread线程设置为守护线程.
守护线程一般应该是一个独立的线程，它的run()方法是一个无限循环

守护线程与其它线程的区别是，如果守护线程是唯一运行着的线程，程序会自动退出

public class Test1 {
	public static void main(String[] args) {
		Thread t1=new Thread(()->{
			while(true)
				System.out.println("守护加血……");
		});
		t1.setDaemon(true);//设置线程t1为守护线程
		t1.start();
		System.out.println("执行结束");
	}
}

public class Test2 {
	public static void main(String[] args) {
		Thread t1 = new Thread(() -> {
			System.out.println("你好，你好" + Thread.currentThread());
			Thread t2 = new Thread(() -> {
				while (true) {
					System.out.println("fsjih");
				}

			});
			t2.setDaemon(true);
			t2.start();

		});
		Thread t2=new Thread(()->{
			for(int i=0;i<10;i++)
				System.out.println("adkjhjdsjakf");
		});
		t2.start();
		t1.start();
	}
}

线程组

Thread类的构造器

public Thread(String name) {
this(null, null, name, 0);
}

public Thread(Runnable target, String name) {
this(null, target, name, 0);
}

Thread线程类中toString方法的定义

public String toString() {
            ThreadGroup group = getThreadGroup();//获取当前线程对象所属的线程组
          if (group != null) {
             return "Thread[" + getName() + "," + getPriority() + "," + group.getName() + "]";
            } else {
             return "Thread[" + getName() + "," + getPriority() + "," + "" + "]";
          }
      }

所有线程都隶属于一个线程组。那可以是一个默认线程组【main】，亦可是一个创建线程时明确指定的组

说明
- 在创建之初，线程被限制到一个组里，而且不能改变到一个不同的组
- 若创建多个线程而不指定一个组，它们就会与创建它的线程属于同一个组

创建线程指定对应的线程组
public Thread(ThreadGroup group, Runnable target)
public Thread(ThreadGroup group, String name)
public Thread(ThreadGroup group, Runnable target, String name)

ThreadGroup myThreadGroup = new ThreadGroup("My Group");//创建线程组
Thread myThread = new Thread(myThreadGroup,"a thread"); //定义线程时指定对应的线程组
theGroup = myThread.getThreadGroup();//获取线程对象所属的线程组

public class Test1 {
	public static void main(String[] args) {
		new Thread(()->{
			for(int i=0;i<10;i++) {
				System.out.println(Thread.currentThread());
			}
		},"哈哈").start();
	}
}

public class Test2 {
	public static void main(String[] args) {
		// 创建线程组，指定名称yan1
		ThreadGroup group = new ThreadGroup("yan1");
		// 创建线程，并指定线程所属的线程组
		Thread t1 = new Thread(group, () -> {
			for (int i = 0; i < 100; i++) {
//				; // Thread[Thread-0,5,yan1]
				ThreadGroup gg = new ThreadGroup("yan1-" + i);
				new Thread(gg, () -> {
					for (int k = 0; k < 100; k++)
						;
				}).start();
			}
		});
		t1.start();
		System.out.println(Thread.currentThread());// 输出当前线程 main
		System.out.println(Thread.currentThread().getPriority());
		System.out.println(Thread.currentThread().getId());
		System.out.println(Thread.currentThread().getName());
		System.out.println("=================");

		// 线程组的用途
		ThreadGroup tg = Thread.currentThread().getThreadGroup();
		System.out.println("ddd:" + tg);// java.lang.ThreadGroup[name=main,maxpri=10]
		System.out.println(tg.getMaxPriority());
		System.out.println(tg.getParent());
		System.out.println(tg.getName());
		
		System.out.println("=================");
		int cc = tg.activeCount();// 获取所有活跃线程线程数
		System.out.println("ddd:" + cc);
		System.out.println("=================");

		Thread[] list = new Thread[cc];
		tg.enumerate(list);// 获取所有获取线程，并存放在Thread[]中
		System.out.println("=================");

		for (Thread temp : list)
			System.out.println("eee:" + temp);
		/*
		 * Thread[main,5,main] Thread[Thread-0,5,yan1]
		 */
		System.out.println("=================");

		tg.list();// 以树装结构显示当前的所有线程组
		/*
		 * java.lang.ThreadGroup[name=main,maxpri=10] Thread[main,5,main]
		 * java.lang.ThreadGroup[name=yan1,maxpri=10]
		 */

		System.out.println("========================");
		cc = group.activeCount();
		System.out.println("yan1:" + cc);
		group.list();
	}
}