java创建的线程池

‘壹’ 【java基础】线程池的原理是什么

什么是线程池？

总归为：池化技术 ---》数据库连接池 缓存架构 缓存池 线程池 内存池，连接池，这种思想演变成缓存架构技术---> JDK设计思想有千丝万缕的联系

首先我们从最核心的ThreadPoolExecutor类中的方法讲起，然后再讲述它的实现原理，接着给出了它的使用示例，最后讨论了一下如何合理配置线程池的大小。

Java 中的 ThreadPoolExecutor 类

java.uitl.concurrent.ThreadPoolExecutor 类是线程池中最核心的一个类，因此如果要透彻地了解Java 中的线程池，必须先了解这个类。下面我们来看一下 ThreadPoolExecutor 类的具体实现源码。

在 ThreadPoolExecutor 类中提供了四个构造方法：

‘贰’ JAVA 线程池使用

package tender nmem eris drawexpert service impl;

import java util List;

import ncurrent ExecutorService;

import ncurrent Executors;

import llections map ListOrderedMap;

/**

吵扰* 类 线程池类 控制程序线程实改销例个数 并实例线程

* @author yangtb

* 时间 / /

*

*/

public class ThreadPool {

private ExecutorService exe=null;//线程池

public ThreadPool(int pool_size)

{

exe=Executors newFixedThreadPool(pool_size);//创建线程池

System out println( the server is ready );

}

/**

* 运行循环实例线程 根据要实例的线程个数 传入条件ID

* @param worknum

*/

public void server(int worknum String id)

{

int i= ;

while(i<worknum)

{

//实例指定升歼旦个线程

WorkerThreadImpl t = new WorkerThreadImpl(id);

exe execute(t);//放入线程池

i++;

}

}

lishixin/Article/program/Java/hx/201311/26215

‘叁’ 线程池的创建方式有几种

线程池是一种常见的多线程并发处理技术，它可以在需要执行任务的时候为任务提供一个线程，从而避免了每次执行任务都需要创建一个新的线程的开销。线程池的创建方式有几种，其中最常见银雹的是使用ThreadPoolExecutor类来创建线程池。
ThreadPoolExecutor类是Java中的一个内置类，它可以用于创建和管理线程池。这个类提供了很多有用的方法和属性，例如可以指定线程池的大小、最大线程数、线程空闲时间等参数。另外，它还提供了一些方法用于提交任务到线程池，并且它会自动管理线程池中的线程，包括创建、销毁和重用等操作。
除了使用ThreadPoolExecutor类来创建线程池外，还可以使用Executors类中提供的一些静态方法来创建线程池，例如newFixedThreadPool()、newCachedThreadPool()和newSingleThreadExecutor()等。这些方法都可以用于创建不同类型的线程池，例如固定大小的孝搏逗线程池、可缓存的线程池和单个线程的线程池等。
总之，线程巧卖池是一种非常重要的多线程并发处理技术，它可以提高程序的性能和可靠性。在实际应用中，我们可以根据实际需求选择不同类型的线程池来创建，并且可以根据需要进行调优和优化，以达到最优的效果。

‘肆’ 什么是java线程池

多线程是为了能够让计算机资源合理的分配，对于处理不同的任务创建不同的线程进行处理，但是计算机创建一个线程或者销毁一个线程所花费的也是比较昂贵的，有时候需要同时处理的事情比较多，就需要我们频繁的进行线程的创建和销毁，这样花费的时间也是比较多的。为了解决这一问题，我们就可以引用线程池的概念。
所谓线程池就是将线程集中管理起来，当需要线程的时候，可以从线程池中获取空闲的线程，这样可以减少线程的频繁创建与销毁，节省很大的时间和减少很多不必要的操作。
在java中提供了ThreadPoolExecutor类来进行线程的管理，这个类继承于AbstractExecutorService，而AbstractExecutorService实现了ExecutorService接口，我们可以使用ThreadPoolExecutor来进行线程池的创建。
在ThreadPoolExecutor的构造方法中，有多个参数，可以配置不同的参数来进行优化。这个类的源码构造方法为：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)其中每个参数代表的意义分别为
corePoolSize : 线程池中的核心线程数量，当线程池中当前的线程数小于这个配置的时候，如果有一个新的任务到来，即使线程池中还存在空闲状态的线程，程序也会继续创建一个新的线程放进线程池当中
maximumPoolSize: 线程池中的线程最大数量
keepAliveTime：当线程池中的线程数量大于配置的核心线程数量(corePoolSize)的时候，如果当前有空闲的线程，则当这个空闲线程可以存在的时间，如果在keepAliveTime这个时间点内没有新的任务使用这个线程，那么这个线程将会结束,核心线程不会结束，但是如果配置了allowCoreThreadTimeOut = true，则当空闲时间超过keepAliveTime之后，线程也会被结束调，默认allowCoreThreadTimeOut = false，即表示默认情况下，核心线程会一直存在于线程池当中。
unit : 空闲线程保持连接时间(keepAliveTime)的时间单位
workQueue：阻塞的任务队列，用来保存等待需要执行的任务。
threadFactory ：线程工厂，可以根据自己的需求去创建线程的对象，设置线程的名称，优先级等属性信息。
handler：当线程池中存在的线程数超过设置的最大值之后，新的任务就会被拒绝，可以自己定义一个拒绝的策略，当新任务被拒绝之后，就会使用hander方法进行处理。
在java中也提供了Executors工具类，在这个工具类中提供了多个创建线程池的静态方法，其中包含newCachedThreadPool、newFixedThreadPool、newScheledThreadPool、newSingleThreadExecutor等。但是他们每个方法都是创建了ThreadPoolExecutor对象，不同的是，每个对象的初始 参数值不一样;

‘伍’ 什么是java线程池

找的资料，你看一下吧：x0dx0a多线程技术主要解决处理器单元内多个线程执行的问题，裤哗它可以显着减让汪少处理器单元的闲置时间，增加处理器单元的吞吐能力。x0dx0a x0dx0a 假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。x0dx0a x0dx0a 如果：T1 + T3 远大于 T2，则可以采用线程池，以提高坦纯仔服务器性能。x0dx0a 一个线程池包括以下四个基本组成部分：x0dx0a 1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；x0dx0a 2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；x0dx0a 3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；x0dx0a 4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。x0dx0a x0dx0a 线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。x0dx0ax0dx0a 线程池不仅调整T1,T3产生的时间段，而且它还显着减少了创建线程的数目，看一个例子：x0dx0ax0dx0a 假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

‘陆’ Java线程：新特征-线程池

Sun在Java 中 对Java线程的类库做了大量的扩展 其中线程池就是Java 的新特征之一 除了线程池之外 还有很多多线程相关的内容 为多线程的编程带来了极大便利 为了编写高效稳定可靠的多线程程序 线程部分的新增内容显得尤为重要 有关Java 线程新特征的内容全部在ncurrent下面 里面包含数目众多的接口和类 熟悉这部羡盯带分API特征是一项艰难的学习过程 目前有关这方面的资料和书籍都少之又少 大所属介绍线程方面书籍还停留在java 之前的知识层面上 当然新特征对做多线程程序没有必须的关系 在java 之前通用可以写出很优秀的多线程程序 只是代价不一样而已 线程池的基本思想还是一种对象池的思想 开辟一块内存空间 里面存放了众多（未死亡）的线程 池中线程执行调度由池管理器来处理 当有线程任务时 从池中取一个 执行完成后线程对象归池 这样可以避免反复创建线程对象所带来的性能开销 节省了系统的资源 在Java 之前 要实现一个线程池是相当有难度的 现在Java 为我们做好了一切 我们只需要按照提供的API来使用 即可享受线程池带来的极大便利 则蚂 Java 的线程池分好多种 固定尺寸的线程池 可变尺寸连接池 在使用线程池之前 必须知道如何去创建一个线程池 在Java 中 需要了解的是ncurrent Executors类的API 这个类提供大量创建连接池的静态方法 是必须掌握的 一 固定大小的线程池 import ncurrent Executors; import ncurrent ExecutorService; /** * Java线程 线程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //创建一个可重用固定线程数的线程池 ExecutorService pool = Executors newFixedThreadPool( ); //创建实现了Runnable接口对象 Thread对象当然也实现了Runnable接口 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); 兄芦Thread t = new MyThread(); Thread t = new MyThread(); //将线程放入池中进行执行 pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); //关闭线程池 pool shutdown(); } } class MyThread extends Thread{ @Override public void run() { System out println(Thread currentThread() getName()+ 正在执行 ); } } pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 Process finished with exit code 二 单任务线程池 在上例的基础上改一行创建pool对象的代码为 //创建一个使用单个 worker 线程的 Executor 以无界队列方式来运行该线程 ExecutorService pool = Executors newSingleThreadExecutor(); 输出结果为 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 Process finished with exit code 对于以上两种连接池 大小都是固定的 当要加入的池的线程（或者任务）超过池最大尺寸时候 则入此线程池需要排队等待 一旦池中有线程完毕 则排队等待的某个线程会入池执行

三 可变尺寸的线程池 与上面的类似 只是改动下pool的创建方式 //创建一个可根据需要创建新线程的线程池 但是在以前构造的线程可用时将重用它们 ExecutorService pool = Executors newCachedThreadPool(); pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 Process finished with exit code 四 延迟连接池 import ncurrent Executors; import ncurrent ScheledExecutorService; import ncurrent TimeUnit; /** * Java线程 线程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //创建一个线程池 它可安排在给定延迟后运行命令或者定期地执行 ScheledExecutorService pool = Executors newScheledThreadPool( ); //创建实现了Runnable接口对象 Thread对象当然也实现了Runnable接口 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); //将线程放入池中进行执行 pool execute(t ); pool execute(t ); pool execute(t ); //使用延迟执行风格的方法 pool schele(t TimeUnit MILLISECONDS); pool schele(t TimeUnit MILLISECONDS); //关闭线程池 pool shutdown(); } } class MyThread extends Thread { @Override public void run() { System out println(Thread currentThread() getName() + 正在执行 ); } } pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 Process finished with exit code

五 单任务延迟连接池 在四代码基础上 做改动 //创建一个单线程执行程序 它可安排在给定延迟后运行命令或者定期地执行 ScheledExecutorService pool = Executors (); pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 Process finished with exit code 六 自定义线程池 import ncurrent ArrayBlockingQueue; import ncurrent BlockingQueue; import ncurrent ThreadPoolExecutor; import ncurrent TimeUnit; /** * Java线程 线程池 自定义线程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //创建等待队列 BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>( ); //创建一个单线程执行程序 它可安排在给定延迟后运行命令或者定期地执行 ThreadPoolExecutor pool = new ThreadPoolExecutor( TimeUnit MILLISECONDS bqueue); //创建实现了Runnable接口对象 Thread对象当然也实现了Runnable接口 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); //将线程放入池中进行执行 pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); //关闭线程池 pool shutdown(); } } class MyThread extends Thread { @Override public void run() { System out println(Thread currentThread() getName() + 正在执行 ); try { Thread sleep( L); } catch (InterruptedException e) { e printStackTrace(); } } }

pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 pool thread 正在执行 Process finished with exit code 创建自定义线程池的构造方法很多 本例中参数的含义如下

ThreadPoolExecutor

用给定的初始参数和默认的线程工厂及处理程序创建新的 ThreadPoolExecutor 使用 Executors 工厂方法之一比使用此通用构造方法方便得多 参数 corePoolSize 池中所保存的线程数 包括空闲线程 maximumPoolSize 池中允许的最大线程数 keepAliveTime 当线程数大于核心时 此为终止前多余的空闲线程等待新任务的最长时间 unit keepAliveTime 参数的时间单位 workQueue 执行前用于保持任务的队列 此队列仅保持由 execute 方法提交的 Runnable 任务 抛出 IllegalArgumentException 如果 corePoolSize 或 keepAliveTime 小于零 或者 maximumPoolSize 小于或等于零 或者 corePoolSize 大于 maximumPoolSize NullPointerException 如果 workQueue 为 null 自定义连接池稍微麻烦些 不过通过创建的ThreadPoolExecutor线程池对象 可以获取到当前线程池的尺寸 正在执行任务的线程数 工作队列等等 有关Java 线程池的内容到此就没有了 更多的内容还需要研读API来获取 lishixin/Article/program/Java/hx/201311/26769

‘柒’ 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( );

else

return null;

}

public boolean isRunning() {

return running;

}

public void stopTasks() {

stopped = true;

}

public void stopTasksSync() {

stopTasks();

while(isRunning()) { try {

sleep( );

} catch (InterruptedException e) {

}

}

}

public void pauseTasks() {

paused = true;

}

public void pauseTasksSync() {

pauseTasks();

while(isRunning()) { try {

sleep( );

} catch (InterruptedException e) {

}

}

}

public void kill() { if(!running)

interrupt();

else

killed = true;

}

public void killSync() {

kill();

while(isAlive()) { try {

sleep( );

} 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 );

break;

}

}

if(paused) {

paused = false;

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

break;

}

}

}

running = false;

}

if(killed) {

killed = false;

break;

}

}

}catch(InterruptedException e) {

return;

}

//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;

return;

}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())

return th;

}

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()

两行代码即可调用

lishixin/Article/program/Java/hx/201311/27203

‘捌’ java for循环中创建线程池

1. 首先要明确线程池的意思，就是线程预先创建好放在一个池里面，使用后不会销毁
   

2. 要区分任务和线程池，任务可以不断添加，但是线程池里线程的个数是固定的，当任务数超过线程数后，后面的任务需要等待有空闲的线程才会执行

3. 所以不断添加任务没有关系，如果池中有50个线程，你添加100个任务同一时间也只会执行50个任务，剩下的50个任务需要等待前面的任务执行完毕后继续执行

4. 所以你的主线程原则上可以不断for，但是你总得有个结束点吧

‘玖’ 线程池创建的7个参数

java多线程开发时，常常用到线程池技术，这篇文章是对创建java线程池时的七个参数的详细解释。从源码中可以看出，线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。下面会对这7个参数一一解释。

线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会 被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。

一个任务被提交到线程池后，首先会缓存到工作队列（后面会介绍）中，如果工作队列满了，则会创建一个新线程，然后从工作队列中的取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize来指定。

一个线程如果处于兆搭空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定。

keepAliveTime的计量单位

新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：

基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程信好池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。

基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。

一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程滑猜铅等等

当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略：

该策略下，在 调用者线程 中直接执行该被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。

该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。

该策略下，直接丢弃任务，什么都不做。

该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

到此，构造线程池时的七个参数，就全部介绍完毕了。

‘拾’ java创建线程池有哪些

ava通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO,
LIFO,
优先级)执行。