当谈到多线程编程和并发控制时，中的线程池是一个无法或缺的工具。线程池准许更有效地治理和控制线程的创立和口头，从而提高运行程序的性能和可保养性。咱们来讨论Java线程池的关键概念和七大参数，以及如何经常使用这些参数来优化多线程运行程序。

1、外围线程数（corePoolSize）

外围线程数（corePoolSize）是Java线程池中的一个关键参数，它指定了线程池中一直坚持优惠的线程数量。这些线程会不时存在，即使它们处于闲暇形态，也会预备立刻口头义务。外围线程数是线程池的基本线程数，用于处置短时义务和突发义务。

须要留意的是，外围线程数通常是线程池中的最小线程数，但不必定是最大线程数。线程池的最大线程数可以大于外围线程数，以应答更大的并发需求。当义务数量超越外围线程数和义务队列容量时，线程池会依据最大线程数创立额外的线程。

外围线程数的正当设置可以协助平衡并发性能和系统资源消耗。太小的外围线程数或许造成义务排队期待口头，而太大的外围线程数或许造成系统资源糜费。因此，在经常使用线程池时，须要细心思考外围线程数的设定，依据运行程序的个性和性能需求来调整。

2、最大线程数（maximumPoolSize）

最大线程数（maximumPoolSize）是Java线程池中的一个关键参数，它定义了线程池中准许的最大线程数量。当义务队列已满且以后线程数小于最大线程数时，线程池将创立新线程来处置义务。最大线程数用于应答突发的高并发需求，以确保线程池可以处置更多的义务。

须要留意的是，最大线程数不应设置得过于庞大，由于每个线程都会占用系统资源，包含内存和CPU期间片。设置过大的最大线程数或许会造成系统资源干枯，反而降落了性能。因此，最大线程数的正当设置须要思考运行程序的性能要求、系统资源和配件性能等要素。

最大线程数是用于控制线程池的最大并发处置才干的关键参数。经过正当设置最大线程数，你可以在高负载状况下确保运行程序的稳固性，并防止义务被拒绝。

3、闲暇线程的存定期间（keepAliveTime）

闲暇线程的存定期间（keepAliveTime）是Java线程池中的一个关键参数，它定义了当线程池中的线程数量超越外围线程数时，多余的闲暇线程期待新义务的最大期间。假设在这个期间内没有新义务抵达，这些闲暇线程将被中断，以监禁系统资源。keepAliveTime通常与期间单位（unit）一同经常使用，以定义存定期间的单位。

通常，keepAliveTime的正当设置须要综合思考运行程序的性能需求、负载形式以及系统资源的可用性。例如，关于常年运转的主机运行程序，或许须要较长的keepAliveTime，以确保非外围线程不会频繁中断和创立。而关于短期义务处置的运行程序，可以将keepAliveTime设置得较短，以更快地监禁资源。

总之，闲暇线程的存定期间（keepAliveTime）是线程池中的一个关键参数，用于灵活治理非外围线程，平衡性能和资源。经过正当设置keepAliveTime，你可以有效地治理线程池，以满足运行程序的需求。

4、期间单位（unit）

期间单位（unit）是Java线程池参数中的一个辅佐参数，用于定义外围线程数、闲暇线程存定期间等期间关系参数的单位。期间单位用于明白指定这些参数的期间量，通常示意为毫秒（milliseconds）、秒（seconds）、分钟（minutes）等。

期间单位在Java线程池中的关键作用是：

例如，以下是经常使用期间单位的示例，其中外围线程数为2，闲暇线程的存定期间为10秒：

ThreadPoolExecutorthreadPool=newThreadPoolExecutor(2,4,10,TimeUnit.SECONDS,newLinkedBlockingQueue<>());

在上述示例中，TimeUnit.SECONDS明白示意了存定期间参数的单位为秒。这样的性能使得代码更易了解和保养。

罕用的期间单位包含：

TimeUnit.NANOSECONDS：纳秒TimeUnit.MICROSECONDS：微秒TimeUnit.MILLISECONDS：毫秒TimeUnit.SECONDS：秒TimeUnit.MINUTES：分钟TimeUnit.HOURS：小时TimeUnit.DAYS：天

经过选用适当的期间单位，你可以依据须要设置线程池的各种期间参数，以满足运行程序的性能和期待期间要求。期间单位是线程池性能中的关键组成局部，有助于确保线程池的正确运转和性能调优。

5、义务队列（workQueue）

义务队列（workQueue）是Java线程池中的一个关键参数，它用于存储期待口头的义务。线程池中的任务线程会从义务队列中失掉义务并口头它们。义务队列的选用对线程池的性能和行为有关键影响，因此须要依据运行程序的需求选用适宜的队列类型。

ThreadPoolExecutorthreadPool=newThreadPoolExecutor(2,4,10,TimeUnit.SECONDS,newLinkedBlockingQueue<>());

在上述示例中，newLinkedBlockingQueue<>()创立了一个无界队列，义务可以有限排队期待口头。

义务队列的选用应依据运行程序的性能需求、义务类型和资源解放来选择。适宜的义务队列可以协助平衡并发性能和资源治理，确保线程池能够高效地处置义务。

6、线程工厂（threadFactory）

线程工厂（ThreadFactory）是Java线程池中的一个关键组成局部，它用于创立线程池中的线程。线程工厂定义了线程的创立形式和属性，准许你自定义线程的称号、优先级、意外处置等属性。线程工厂提供了更灵敏的形式来创立线程，以顺应特定的运行需求。

以下是关于线程工厂的关键特点和用途：

ThreadFactorycustomThreadFactory=newCustomThreadFactory("MyThreadPool-Worker-");ThreadPoolExecutorthreadPool=newThreadPoolExecutor(2,4,10,TimeUnit.SECONDS,newLinkedBlockingQueue<>(),customThreadFactory);

在上述示例中，CustomThreadFactory是一个自定义的线程工厂类，它为线程设置了自定义的称号前缀。

线程工厂的经常使用有助于更好地控制线程的行为和属性，使线程池顺应不同的运行需求。它也有助于提高代码的可保养性和可读性，由于可以明白指定线程的属性和行为。

7、拒绝战略（handler）

拒绝战略（RejectionPolicy），也被称为拒绝处置战略，是Java线程池中的一个关键参数。当线程池的义务队列已满并且线程池的任务线程数曾经到达最大线程数时，新提交的义务无法被立刻口头。此时，拒绝战略定义了应该如何处置这些无法口头的义务。

Java线程池提供了多种不同的拒绝战略，你可以依据运行程序的需求来选用适宜的战略。以下是经常出现的拒绝战略：

你可以在创立线程池时经过指定拒绝战略来选用所需的处置形式：

ThreadPoolExecutorthreadPool=newThreadPoolExecutor(2,4,10,TimeUnit.SECONDS,newLinkedBlockingQueue<>(),newThreadPoolExecutor.AbortPolicy());

选用适当的拒绝战略取决于你的运行需求。严厉的战略可以协助包全线程池免受适度负载，但或许造成义务失落。较宽松的战略可以防止义务失落，但或许会降落性能。因此，须要依据运行程序的性能、牢靠性和义务处置需求来选用适宜的拒绝战略。

在多线程编程中，Java线程池是一个弱小的工具，它可以协助你有效地治理线程，提高运行程序的并发性能。经过深化了解线程池的各个参数和性能，你可以更好地利用这一工具，优化你的多线程运行程序，提供更好的用户体验。

---

java 线程池机制的原理是什么？

线程池属于对象池.所有对象池都具有一个非常重要的共性,就是为了最大程度复用对象.那么线程池的最重要的特征也就是最大程度利用线程.首先,创建线程本身需要额外(相对于执行任务而必须的资源)的开销.作业系统在每创建一个线程时,至少需要创建以下资源:（1） 线程内核对象：用于对线程上下文的管理.（2） 用户模式执行栈.（3） 内核模式执行栈.这些资源被线程占有后作业系统和用户都无法使用.相反的过程,销毁线程需要回收资源,也需要一定开销.其次,过多的线程将导致过度的切换.线程切换带来的性能更是不可估量.系统完成线程切换要经过以下过程:（1） 从用户模式切换到内核模式.（2） 将CPU寄存器的值保存到当前线程的内核对象中.（3）打开一个自旋锁,根据调度策略决定下一个要执行的线程.释放自旋锁,如果要执行的线程不是同一进程中的线程,还需要切换虚拟内存等进程环境.（4） 将要执行的线程的内核对象的值写到CPU寄存器中.（5） 切换到用户模式执行新线程的执行逻辑.所以线程池的目的就是为了减少创建和切换线程的额外开销,利用已经的线程多次循环执行多个任务从而提高系统的处理能力.

Java实现通用线程池

线程池通俗的描述就是预先创建若干空闲线程 等到需要用多线程去处理事务的时候去唤醒某些空闲线程执行处理任务 这样就省去了频繁创建线程的时间 因为频 繁创建线程是要耗费大量的CPU资源的 如果一个应用程序需要频繁地处理大量并发事务 不断的创建销毁线程往往会大大地降低系统的效率 这时候线程池就派 上用场了

本文旨在使用Java语言编写一个通用的线程池 当需要使用线程池处理事务时 只需按照指定规范封装好事务处理对象 然后用已有的线程池对象去自动选择空 闲线程自动调用事务处理对象即可 并实现线程池的动态修改（修改当前线程数 最大线程数等） 下面是实现代码

//ThreadTask java

package polarman threadpool;

*线程任务

* @author ryang

public interface ThreadTask {

public void run();

//PooledThread java

package polarman threadpool;

import java util Collection; import java util Vector;

*接受线程池管理的线程

* @author ryang

public class PooledThread extends Thread {

protected Vector tasks = new Vector();

protected boolean running = false;

protected boolean stopped = false;

protected boolean paused = false;

protected boolean killed = false;

private ThreadPool pool;

public PooledThread(ThreadPool pool) { this pool = pool;

public void putTask(ThreadTask task) { tasks add(task);

public void putTasks(ThreadTask[] tasks) { for(int i= ; i<tasks length; i++) this tasks add(tasks[i]);

public void putTasks(Collection tasks) { this tasks addAll(tasks);

protected ThreadTask popTask() { if(tasks size() > ) return (ThreadTask)tasks remove( );

return null;

public boolean isRunning() {

return running;

public void stopTasks() {

stopped = true;

public void stopTasksSync() {

stopTasks();

while(isRunning()) { try {

} catch (InterruptedException e) {

public void pauseTasks() {

paused = true;

public void pauseTasksSync() {

pauseTasks();

while(isRunning()) { try {

} catch (InterruptedException e) {

public void kill() { if(!running)

interrupt();

killed = true;

public void killSync() {

while(isAlive()) { try {

} catch (InterruptedException e) {

public synchronized void startTasks() {

running = true;

this notify();

public synchronized void run() { try { while(true) { if(!running || tasks size() == ) { pool notifyForIdleThread(); //System out println(Thread currentThread() getId() + : 空闲 ); this wait(); }else {

ThreadTask task;

while((task = popTask()) != null) { task run(); if(stopped) {

stopped = false;

if(tasks size() > ) { tasks clear(); System out println(Thread currentThread() getId() + : Tasks are stopped );

if(paused) {

paused = false;

if(tasks size() > ) { System out println(Thread currentThread() getId() + : Tasks are paused );

running = false;

if(killed) {

killed = false;

}catch(InterruptedException e) {

//System out println(Thread currentThread() getId() + : Killed );

//ThreadPool java

package polarman threadpool;

import java util Collection; import java util Iterator; import java util Vector;

*线程池

* @author ryang

public class ThreadPool {

protected int maxPoolSize;

protected int initPoolSize;

protected Vector threads = new Vector();

protected boolean initialized = false;

protected boolean hasIdleThread = false;

public ThreadPool(int maxPoolSize int initPoolSize) { this maxPoolSize = maxPoolSize; this initPoolSize = initPoolSize;

public void init() {

initialized = true;

for(int i= ; i<initPoolSize; i++) {

PooledThread thread = new PooledThread(this);

thread start(); threads add(thread);

//System out println( 线程池初始化结束 线程数= + threads size() + 最大线程数= + maxPoolSize);

public void setMaxPoolSize(int maxPoolSize) { //System out println( 重设最大线程数 最大线程数= + maxPoolSize); this maxPoolSize = maxPoolSize;

if(maxPoolSize < getPoolSize())

setPoolSize(maxPoolSize);

*重设当前线程数

* 若需杀掉某线程 线程不会立刻杀掉 而会等到线程中的事务处理完成* 但此方法会立刻从线程池中移除该线程 不会等待事务处理结束

* @param size

public void setPoolSize(int size) { if(!initialized) {

initPoolSize = size;

}else if(size > getPoolSize()) { for(int i=getPoolSize(); i<size && i<maxPoolSize; i++) {

PooledThread thread = new PooledThread(this);

thread start(); threads add(thread);

}else if(size < getPoolSize()) { while(getPoolSize() > size) { PooledThread th = (PooledThread)threads remove( ); th kill();

//System out println( 重设线程数 线程数= + threads size());

public int getPoolSize() { return threads size();

protected void notifyForIdleThread() {

hasIdleThread = true;

protected boolean waitForIdleThread() {

hasIdleThread = false;

while(!hasIdleThread && getPoolSize() >= maxPoolSize) { try { Thread sleep( ); } catch (InterruptedException e) {

return false;

return true;

public synchronized PooledThread getIdleThread() { while(true) { for(Iterator itr=erator(); itr hasNext();) { PooledThread th = (PooledThread)itr next(); if(!th isRunning())

if(getPoolSize() < maxPoolSize) {

PooledThread thread = new PooledThread(this);

thread start(); threads add(thread);

return thread;

//System out println( 线程池已满 等待 );

if(waitForIdleThread() == false)

return null;

public void processTask(ThreadTask task) {

PooledThread th = getIdleThread();

if(th != null) { th putTask(task); th startTasks();

public void processTasksInSingleThread(ThreadTask[] tasks) {

PooledThread th = getIdleThread();

if(th != null) { th putTasks(tasks); th startTasks();

public void processTasksInSingleThread(Collection tasks) {

PooledThread th = getIdleThread();

if(th != null) { th putTasks(tasks); th startTasks();

下面是线程池的测试程序

//ThreadPoolTest java

import java io BufferedReader; import java io IOException; import java io InputStreamReader;

import polarman threadpool ThreadPool; import polarman threadpool ThreadTask;

public class ThreadPoolTest {

public static void main(String[] args) { System out println( quit 退出 ); System out println( task A 启动任务A 时长为 秒 ); System out println( size 设置当前线程池大小为 ); System out println( max 设置线程池最大线程数为 ); System out println();

final ThreadPool pool = new ThreadPool( ); pool init();

Thread cmdThread = new Thread() { public void run() {

BufferedReader reader = new BufferedReader(new InputStreamReader(System in));

while(true) { try { String line = reader readLine(); String words[] = line split( ); if(words[ ] equalsIgnoreCase( quit )) { System exit( ); }else if(words[ ] equalsIgnoreCase( size ) && words length >= ) { try { int size = Integer parseInt(words[ ]); pool setPoolSize(size); }catch(Exception e) {

}else if(words[ ] equalsIgnoreCase( max ) && words length >= ) { try { int max = Integer parseInt(words[ ]); pool setMaxPoolSize(max); }catch(Exception e) {

}else if(words[ ] equalsIgnoreCase( task ) && words length >= ) { try { int timelen = Integer parseInt(words[ ]); SimpleTask task = new SimpleTask(words[ ] timelen * ); pool processTask(task); }catch(Exception e) {

} catch (IOException e) { e printStackTrace();

cmdThread start();

for(int i= ; i< ; i++){

SimpleTask task = new SimpleTask( Task + i (i+ )* ); pool processTask(task);

class SimpleTask implements ThreadTask {

private String taskName;

private int timeLen;

public SimpleTask(String taskName int timeLen) { this taskName = taskName; this timeLen = timeLen;

public void run() { System out println(Thread currentThread() getId() +

: START TASK + taskName + );

try { Thread sleep(timeLen); } catch (InterruptedException e) {

System out println(Thread currentThread() getId() +

: END TASK + taskName + );

使用此线程池相当简单 下面两行代码初始化线程池

ThreadPool pool = new ThreadPool( ); pool init();

要处理的任务实现ThreadTask 接口即可（如测试代码里的SimpleTask） 这个接口只有一个方法run()

两行代码即可调用

lishixinzhi/Article/program/Java/hx//