1. java线程池怎么实现
要想理解清楚java线程池实现原理，明白下面几个问题就可以了：
(1)：线程池存在哪些状态，这些状态之间是如何进行切换的呢？
(2)：线程池的种类有哪些？
(3)：创建线程池需要哪些参数，这些参数的具体含义是什么？
(4)：将任务添加到线程池之后运行流程？
(5)：线程池是怎么做到重用线程的呢？
(6)：线程池的关闭
首先回答第一个问题：线程池存在哪些状态；
查看ThreadPoolExecutor源码便知晓：
[java]view plain
//runStateisstoredinthehigh-orderbits
privatestaticfinalintRUNNING=-1<<COUNT_BITS;
privatestaticfinalintSHUTDOWN=0<<COUNT_BITS;
privatestaticfinalintSTOP=1<<COUNT_BITS;
privatestaticfinalintTIDYING=2<<COUNT_BITS;
=3<<COUNT_BITS;
存在5种状态：
<1>Running：可以接受新任务，同时也可以处理阻塞队列里面的任务；
<2>Shutdown：不可以接受新任务，但是可以处理阻塞队列里面的任务；
<3>Stop：不可以接受新任务，也不处理阻塞队列里面的任务，同时还中断正在处理的任务；
<4>Tidying：属于过渡阶段，在这个阶段表示所有的任务已经执行结束了，当前线程池中是不存在有效的线程的，并且将要调用terminated方法；
<5>Terminated：终止状态，这个状态是在调用完terminated方法之后所处的状态；
那么这5种状态之间是如何进行转换的呢？查看ThreadPoolExecutor源码里面的注释便可以知道啦：
[java]view plain
*RUNNING->SHUTDOWN
*Oninvocationofshutdown(),perhapsimplicitlyinfinalize()
*(RUNNINGorSHUTDOWN)->STOP
*OninvocationofshutdownNow()
*SHUTDOWN->TIDYING
*Whenbothqueueandpoolareempty
*STOP->TIDYING
*Whenpoolisempty
*TIDYING->TERMINATED
*Whentheterminated()hookmethodhascompleted
从上面可以看到，在调用shutdown方法的时候，线程池状态会从Running转换成Shutdown；在调用shutdownNow方法的时候，线程池状态会从Running/Shutdown转换成Stop；在阻塞队列为空同时线程池为空的情况下，线程池状态会从Shutdown转换成Tidying；在线程池为空的情况下，线程池状态会从Stop转换成Tidying；当调用terminated方法之后，线程池状态会从Tidying转换成Terminate；
在明白了线程池的各个状态以及状态之间是怎么进行切换之后，我们来看看第二个问题，线程池的种类：
(1)：CachedThreadPool：缓存线程池，该类线程池中线程的数量是不确定的，理论上可以达到Integer.MAX_VALUE个，这种线程池中的线程都是非核心线程，既然是非核心线程，那么就存在超时淘汰机制了，当里面的某个线程空闲时间超过了设定的超时时间的话，就会回收掉该线程；
(2)：FixedThreadPool：固定线程池，这类线程池中是只存在核心线程的，对于核心线程来说，如果我们不设置allowCoreThreadTimeOut属性的话是不存在超时淘汰机制的，这类线程池中的corePoolSize的大小是等于maximumPoolSize大小的，也就是说，如果线程池中的线程都处于活动状态的话，如果有新任务到来，他是不会开辟新的工作线程来处理这些任务的，只能将这些任务放到阻塞队列里面进行等到，直到有核心线程空闲为止；
(3)：ScheledThreadPool：任务线程池，这种线程池中核心线程的数量是固定的，而对于非核心线程的数量是不限制的，同时对于非核心线程是存在超时淘汰机制的，主要适用于执行定时任务或者周期性任务的场景；
(4)：SingleThreadPool：单一线程池，线程池里面只有一个线程，同时也不存在非核心线程，感觉像是FixedThreadPool的特殊版本，他主要用于确保任务在同一线程中的顺序执行，有点类似于进行同步吧；
接下来我们来看第三个问题，创建线程池需要哪些参数：
同样查看ThreadPoolExecutor源码，查看创建线程池的构造函数：
[java]view plain
publicThreadPoolExecutor(intcorePoolSize,
intmaximumPoolSize,
longkeepAliveTime,
TimeUnitunit,
BlockingQueue<Runnable>workQueue,
ThreadFactorythreadFactory,
)
不管你调用的是ThreadPoolExecutor的哪个构造函数，最终都会执行到这个构造函数的，这个构造函数有7个参数，正是由于对这7个参数值的赋值不同，造成生成不同类型的线程池，比如我们常见的CachedThreadPoolExecutor、FixedThreadPoolExecutor
SingleThreadPoolExecutor、ScheledThreadPoolExecutor，我们老看看这几个参数的具体含义：
<1>corePoolSize：线程池中核心线程的数量；当提交一个任务到线程池的时候，线程池会创建一个线程来执行执行任务，即使有其他空闲的线程存在，直到线程数达到corePoolSize时不再创建，这时候会把提交的新任务放入到阻塞队列中，如果调用了线程池的preStartAllCoreThreads方法，则会在创建线程池的时候初始化出来核心线程；
<2>maximumPoolSize：线程池允许创建的最大线程数；如果阻塞队列已经满了，同时已经创建的线程数小于最大线程数的话，那么会创建新的线程来处理阻塞队列中的任务；
<3>keepAliveTime：线程活动保持时间，指的是工作线程空闲之后继续存活的时间，默认情况下，这个参数只有线程数大于corePoolSize的时候才会起作用，即当线程池中的线程数目大于corePoolSize的时候，如果某一个线程的空闲时间达到keepAliveTime，那么这个线程是会被终止的，直到线程池中的线程数目不大于corePoolSize；如果调用allowCoreThreadTimeOut的话，在线程池中线程数量不大于corePoolSize的时候，keepAliveTime参数也可以起作用的，知道线程数目为0为止；
<4>unit：参数keepAliveTime的时间单位；
<5>workQueue：阻塞队列；用于存储等待执行的任务，有四种阻塞队列类型，ArrayBlockingQueue(基于数组的有界阻塞队列)、LinkedBlockingQueue(基于链表结构的阻塞队列)、SynchronousQueue(不存储元素的阻塞队列)、PriorityBlockingQueue(具有优先级的阻塞队列)；
<6>threadFactory：用于创建线程的线程工厂；
<7>handler：当阻塞队列满了，且没有空闲线程的情况下，也就是说这个时候，线程池中的线程数目已经达到了最大线程数量，处于饱和状态，那么必须采取一种策略来处理新提交的任务，我们可以自己定义处理策略，也可以使用系统已经提供给我们的策略，先来看看系统为我们提供的4种策略，AbortPolicy(直接抛出异常)、CallerRunsPolicy(只有调用者所在的线程来运行任务)、DiscardOldestPolicy(丢弃阻塞队列中最近的一个任务，并执行当前任务)、Discard(直接丢弃)；
接下来就是将任务添加到线程池之后的运行流程了；
我们可以调用submit或者execute方法，两者最大的区别在于，调用submit方法的话，我们可以传入一个实现Callable接口的对象，进而能在当前任务执行结束之后通过Future对象获得任务的返回值，submit内部实际上还是执行的execute方法；而调用execute方法的话，是不能获得任务执行结束之后的返回值的；此外，调用submit方法的话是可以抛出异常的，但是调用execute方法的话，异常在其内部得到了消化，也就是说异常在其内部得到了处理，不会向外传递的；
因为submit方法最终也是会执行execute方法的，因此我们只需要了解execute方法就可以了：
在execute方法内部会分三种情况来进行处理：
<1>：首先判断当前线程池中的线程数量是否小于corePoolSize，如果小于的话，则直接通过addWorker方法创建一个新的Worker对象来执行我们当前的任务；
<2>：如果说当前线程池中的线程数量大于corePoolSize的话，那么会尝试将当前任务添加到阻塞队列中，然后第二次检查线程池的状态，如果线程池不在Running状态的话，会将刚刚添加到阻塞队列中的任务移出，同时拒绝当前任务请求；如果第二次检查发现当前线程池处于Running状态的话，那么会查看当前线程池中的工作线程数量是否为0，如果为0的话，就会通过addWorker方法创建一个Worker对象出来处理阻塞队列中的任务；
<3>：如果原先线程池就不处于Running状态或者我们刚刚将当前任务添加到阻塞队列的时候出现错误的话，那么会去尝试通过addWorker创建新的Worker来处理当前任务，如果添加失败的话，则拒绝当前任务请求；
可以看到在上面的execute方法中，我们仅仅只是检查了当前线程池中的线程数量有没有超过corePoolSize的情况，那么当前线程池中的线程数量有没有超过maximumPoolSize是在哪里检测的呢？实际上是在addWorker方法里面了，我们可以看下addWorker里面的一段代码：
[java]view plain
if(wc>=CAPACITY||
wc>=(core?corePoolSize:maximumPoolSize))
returnfalse;
如果当前线程数量超过maximumPoolSize的话，直接就会调用return方法，返回false；
其实到这里我们很明显可以知道，一个线程池中线程的数量实际上就是这个线程池中Worker的数量，如果Worker的大小超过了corePoolSize，那么任务都在阻塞队列里面了，Worker是Java对我们任务的一个封装类，他的声明是酱紫的：
[java]view plain
privatefinalclassWorker
implementsRunnable
可以看到他实现了Runnable接口，他是在addWorker方法里面通过new Worker(firstTask)创建的，我们来看看他的构造函数就知道了：
[java]view plain
Worker(RunnablefirstTask){
setState(-1);//
this.firstTask=firstTask;
this.thread=getThreadFactory().newThread(this);
}
而这里的firstTask其实就是我们调用execute或者submit的时候传入的那个参数罢了，一般来说这些参数是实现Callable或者Runnable接口的；
在通过addWorker方法创建出来Worker对象之后，这个方法的最后会执行Worker内部thread属性的start方法，而这个thread属性实际上就是封装了Worker的Thread，执行他的start方法实际上执行的是Worker的run方法，因为Worker是实现了Runnable接口的，在run方法里面就会执行runWorker方法，而runWorker方法里面首先会判断当前我们传入的任务是否为空，不为空的话直接就会执行我们通过execute或者submit方法提交的任务啦，注意一点就是我们虽然会通过submit方法提交实现了Callable接口的对象，但是在调用submit方法的时候，其实是会将Callable对象封装成实现了Runnable接口对象的，不信我们看看submit方法源码是怎么实现的：
[java]view plain
public<T>Future<T>submit(Callable<T>task){
if(task==null)thrownewNullPointerException();
RunnableFuture<T>ftask=newTaskFor(task);
execute(ftask);
returnftask;
}
看到没有呢，实际上在你传入实现了Callable接口对象的时候，在submit方法里面是会将其封装成RunnableFuture对象的，而RunnableFuture接口是继承了Runnable接口的；那么说白了其实就是直接执行我们提交任务的run方法了；如果为空的话，则会通过getTask方法从阻塞队列里面拿出一个任务去执行；在任务执行结束之后继续从阻塞队列里面拿任务，直到getTask的返回值为空则退出runWorker内部循环，那么什么情况下getTask返回为空呢？查看getTask方法的源码注释可以知道：在Worker必须需要退出的情况下getTask会返回空，具体什么情况下Worker会退出呢？(1)：当Worker的数量超过maximumPoolSize的时候；(2)：当线程池状态为Stop的时候；(3)：当线程池状态为Shutdown并且阻塞队列为空的时候；(4)：使用等待超时时间从阻塞队列中拿数据，但是超时之后仍然没有拿到数据；
如果runWorker方法退出了它里面的循环，那么就说明当前阻塞队列里面是没有任务可以执行的了，你可以看到在runWorker方法内部的finally语句块中执行了processWorkerExit方法，用来对Worker对象进行回收操作，这个方法会传入一个参数表示需要删除的Worker对象；在进行Worker回收的时候会调用tryTerminate方法来尝试关闭线程池，在tryTerminate方法里面会检查是否有Worker在工作，检查线程池的状态，没问题的话就会将当前线程池的状态过渡到Tidying，之后调用terminated方法，将线程池状态更新到Terminated；
从上面的分析中，我们可以看出线程池运行的4个阶段：
(1)：poolSize < corePoolSize，则直接创建新的线程(核心线程)来执行当前提交的任务；
(2)：poolSize = corePoolSize，并且此时阻塞队列没有满，那么会将当前任务添加到阻塞队列中，如果此时存在工作线程(非核心线程)的话，那么会由工作线程来处理该阻塞队列中的任务，如果此时工作线程数量为0的话，那么会创建一个工作线程(非核心线程)出来；
(3)：poolSize = corePoolSize，并且此时阻塞队列已经满了，那么会直接创建新的工作线程(非核心线程)来处理阻塞队列中的任务；
(4)：poolSize = maximumPoolSize，并且此时阻塞队列也满了的话，那么会触发拒绝机制，具体决绝策略采用的是什么就要看我们创建ThreadPoolExecutor的时候传入的RejectExecutionHandler参数了；
接下来就是线程池是怎么做到重用线程的呢？
个人认为线程池里面重用线程的工作是在getTask里面实现的，在getTask里面是存在两个for死循环嵌套的，他会不断的从阻塞对列里面取出需要执行的任务，返回给我们的runWorker方法里面，而在runWorker方法里面只要getTask返回的任务不是空就会执行该任务的run方法来处理它，这样一直执行下去，直到getTask返回空为止，此时的情况就是阻塞队列里面没有任务了，这样一个线程处理完一个任务之后接着再处理阻塞队列中的另一个任务，当然在线程池中的不同线程是可以并发处理阻塞队列中的任务的，最后在阻塞队列内部不存在任务的时候会去判断是否需要回收Worker对象，其实Worker对象的个数就是线程池中线程的个数，至于什么情况才需要回收，上面已经说了，就是四种情况了；
最后就是线程池是怎样被关闭的呢？
涉及到线程池的关闭，需要用到两个方法，shutdown和shutdownNow，他们都是位于ThreadPoolExecutor里面的，对于shutdown的话，他会将线程池状态切换成Shutdown，此时是不会影响对阻塞队列中任务执行的，但是会拒绝执行新加进来的任务，同时会回收闲置的Worker；而shutdownNow方法会将线程池状态切换成Stop，此时既不会再去处理阻塞队列里面的任务，也不会去处理新加进来的任务，同时会回收所有Worker；
2. java如何写一个线程池（线程池大小可定义为3），
packagecn.sdeit.servlet;
importjava.io.IOException;
importjava.io.PrintWriter;
importjava.sql.Connection;
importjava.sql.PreparedStatement;
importjava.sql.SQLException;
importjavax.servlet.ServletException;
importjavax.servlet.annotation.WebServlet;
importjavax.servlet.http.HttpServlet;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importcn.sdeit.beans.Team;
importcn.sdeit.beans.User;
importcn.sdeit.mysql.ConnectMySql;
/**
*
*/
@WebServlet(name="JoinTeam",urlPatterns={"/JoinTeam"})
{
=1L;
privateStringcaptainName=null;
privateStringteamName=null;
privatePrintWriterwriter=null;
/**
*@seeHttpServlet#HttpServlet()
*/
publicJoinTeam()
{
();
}
protectedvoiddoGet(HttpServletRequestrequest,
HttpServletResponseresponse)throwsServletException,IOException
{
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
response.setContentType("text/html");
writer=response.getWriter();
captainName=request.getParameter("name");
teamName=request.getParameter("team");
if(teamName.equals((newTeam()).getTeamNameByCaptainName(captainName)))
{
intresult=joinTeam(((User)request.getSession().getAttribute("oldUser")).getEmail());
if(result==0)
{
showErrorMessage("抱歉！</br>服务器内部错误，加入队伍失败！请及时反馈管理员！");
}
else
{
response.sendRedirect("mine.jsp");
}
}
else
{
showErrorMessage("抱歉！</br>没有找到符合条件的团队！请联系您的队长解决，若信息无误，且问题一直出现，请联系管理员！");
writer.flush();
writer.close();
}
}
privatevoidshowErrorMessage(Stringerror)
{
writer.write(error);
writer.flush();
writer.close();
}
privateintjoinTeam(Stringemail)
{
intposition=(newTeam()).getMinEmptyMemberPosition(teamName);
intresult=0;
if(position==-1)
{
showErrorMessage("抱歉！</br>此小组人数已达到上限，请更换队伍或者协商队长调整组员结构！");
}
else
{
Connectionconnection=ConnectMySql.createConnection();
Stringsql="updateteamsetmember"+position+""+"=?wherename=?";
PreparedStatementprepared=ConnectMySql.createPreparedStatement(connection,sql);
try
{
prepared.setString(1,email);
prepared.setString(2,teamName);
result=prepared.executeUpdate();
connection.close();
prepared.close();
}catch(SQLExceptione)
{
e.printStackTrace();
}
}
returnresult;
}
}
3. 几种开源Java Web容器线程池的实现方法简介
其中Resin从V3.0后需要购买才能用于商业目的，而其他两种则是纯开源的。可以分别从他们的网站上下载最新的二进制包和源代码。
作为Web容器，需要承受较高的访问量，能够同时响应不同用户的请求，能够在恶劣环境下保持较高的稳定性和健壮性。在HTTP服务器领域，ApacheHTTPD的效率是最高的，也是最为稳定的，但它只能处理静态页面的请求，如果需要支持动态页面请求，则必须安装相应的插件，比如mod_perl可以处理Perl脚本，mod_python可以处理Python脚本。
上面介绍的三中Web容器，都是使用Java编写的HTTP服务器，当然他们都可以嵌到Apache中使用，也可以独立使用。分析它们处理客户请求的方法有助于了解Java多线程和线程池的实现方法，为设计强大的多线程服务器打好基础。
Tomcat是使用最广的Java Web容器，功能强大，可扩展性强。最新版本的Tomcat（5.5.17）为了提高响应速度和效率，使用了Apache Portable Runtime（APR）作为最底层，使用了APR中包含Socket、缓冲池等多种技术，性能也提高了。APR也是Apache HTTPD的最底层。可想而知，同属于ASF（Apache Software Foundation）中的成员，互补互用的情况还是很多的，虽然使用了不同的开发语言。
Tomcat 的线程池位于tomcat-util.jar文件中，包含了两种线程池方案。方案一：使用APR的Pool技术，使用了JNI；方案二：使用Java实现的ThreadPool。这里介绍的是第二种。如果想了解APR的Pool技术，可以查看APR的源代码。
ThreadPool默认创建了5个线程，保存在一个200维的线程数组中，创建时就启动了这些线程，当然在没有请求时，它们都处理等待状态（其实就是一个while循环，不停的等待notify）。如果液桐有请求时，空闲线程会被唤醒执行用户的请求。
具体的请求过程是：服务启动时，创建一个一维线程数组（maxThread＝200个），并创建空闲线程(minSpareThreads＝5个)随时等待用户请求。当有用户请求时，调用 threadpool.runIt(ThreadPoolRunnable)方法，将一个需要执行的实例传给ThreadPool中。其中用户需要执行的实例必须实现ThreadPoolRunnable接口。 ThreadPool首先查找空闲的线程，如果有则用它运行要执行ThreadPoolRunnable；如果没有空闲线程并且没有超过 maxThreads，就一次性创建minSpareThreads个空闲线程；如果已经超过了maxThreads了，就等待空闲线程了。总之，要找到空闲的线程，以便用它执行实例。找到后，将该线程从线程数组中移走。接着唤醒已经找到的空闲线程，用它运行执行实例（ThreadPoolRunnable）。运行完ThreadPoolRunnable后，就将该线程闹枣坦重新放到线程数组中，作为空闲线程供后续使用。
由此可以看出，Tomcat的线程池实现是比较简单的，ThreadPool.java也只有840行代码。用一个一维数组保存空闲的线程，每次以一个较小步伐（5个）创建空闲线程并放到线程池中。使岩辩用时从数组中移走空闲的线程，用完后，再归还给线程池。
4. 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
5. java创建线程池有哪些
ava通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO,
LIFO,
优先级)执行。
6. 创建线程有几种方式和Java中常用的线程池
java创建线程的方式有三种
第一种是继承Thread类 实现方法run() 不可以抛异常 无返回值
第二种回是答实现Runnable接口 实现方法run() 不可以抛异常 无返回值
第三种是实现Callable<T>接口,接口中要覆盖的方法是 public <T> call() 注意:此方法可以抛异常,而前两种不能 而且此方法可以有返回值
第三种如何运行呢 Callable接口在util.concurrent包中,由线程池提交
import java.util.concurrent.*;
ExecutorService e = Executors.newFixedThreadPool(10); 参数表示最多可以运行几个线程
e.submit(); 这个里面参数传 实现Callable接口那个类的对象
7. 如何用java线程池做
当一个线程完成任务时，它会从队列中取下一个任务来执行。
当一个线程无裤厅谨事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。
这样的过程说明，并不是先加入任务就一定会先执行。假设队列大小为 10，corePoolSize 为 3，maximumPoolSize 为 6，那么当加入 20 个任务时，执行的顺序就是这样的：首先执行任务 1、2、3，然后任务 4~13 被放入队列。这时候队列满了，任务 14、15、16 会被马上执行，而任务 17~20 则胡基会抛伏岩出异常。最终顺序是：1、2、3、14、15、16、4、5、6、7、8、9、10、11、12、13。
8. Java线程池
java常用的线程池有三种：
1.
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads)创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
参数：
nThreads - 池中的线程数
返回：
新创建的线程池
抛出：
IllegalArgumentException - 如果 nThreads <= 0
2.
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor()创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
返回：
新创建的单线程 Executor
3.
newCachedThreadPool
public static ExecutorService newCachedThreadPool()创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。注意，可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但细节不同（例如超时参数）的线程池。
返回：
新创建的线程池
9. java 怎么实现线程池
最简单的可以利用java.util.concurrent.Executors
调用Executors.newCachedThreadPool()获取缓冲式线程池
Executors.newFixedThreadPool(int nThreads)获取固定大小的线程池
10. Java线程池
线程池是一种多线程处理形式，处理过程中将任务添加队列，然后在创建线程后自动启动这些任务，每个线程都使用默认的堆栈大小，以默认的优先级运行，并处在多线程单元中，如果某个线程在托管代码中空闲，则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后辅助线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才能启动。
java里面的线程池的顶级接口是Executor，Executor并不是一个线程池，而只是一个执行线程的工具，而真正的线程池是ExecutorService。
java中的有哪些线程池？
1.newCachedThreadPool创建一个可缓存线程池程
2.newFixedThreadPool 创建一个定长线程池
3.newScheledThreadPool 创建一个定长线程池
4.newSingleThreadExecutor 创建一个单线程化的线程池
————————————————