通常大家知道tomcat的线程池是可以配置的，去找到conf下面的的server.xml就可以搞定，先配置指定参数
引用
<Service name="Catalina">
<!--The connectors can use a shared executor, you can define one or more named thread pools-->
<!--
<Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
maxThreads="150" minSpareThreads="4"/>
-->
在配置连接器使用它，注释中都给出了例子
引用
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
<!-- A "Connector" using the shared thread pool-->
<!--
<Connector executor="tomcatThreadPool"
port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
-->
但现在不是想说这个，是想看看tomcat源码里的线程池，只看配置文件没啥意义，不好玩
开始->>
首先看tomcat的源码，ThreadPool里面的成员变量
private static Log log = LogFactory.getLog(ThreadPool.class);
private static StringManager sm =
StringManager.getManager("org.apache.tomcat.util.threads.res");
private static boolean logfull=true;
/*
* Default values ...
*/
public static final int MAX_THREADS = 200;
public static final int MAX_THREADS_MIN = 10;
public static final int MAX_SPARE_THREADS = 50;
public static final int MIN_SPARE_THREADS = 4;
public static final int WORK_WAIT_TIMEOUT = 60*1000;
/*
* Where the threads are held.
*/
protected ControlRunnable[] pool = null;
/*
* A monitor thread that monitors the pool for idel threads.
*/
protected MonitorRunnable monitor;
/*
* Max number of threads that you can open in the pool.
*/
protected int maxThreads;
/*
* Min number of idel threads that you can leave in the pool.
*/
protected int minSpareThreads;
/*
* Max number of idel threads that you can leave in the pool.
*/
protected int maxSpareThreads;
/*
* Number of threads in the pool.
*/
protected int currentThreadCount;
/*
* Number of busy threads in the pool.
*/
protected int currentThreadsBusy;
/*
* Flag that the pool should terminate all the threads and stop.
*/
protected boolean stopThePool;
/* Flag to control if the main thread is 'daemon' */
protected boolean isDaemon=true;
/** The threads that are part of the pool.
* Key is Thread, value is the ControlRunnable
*/
protected Hashtable threads=new Hashtable();
protected Vector listeners=new Vector();
/** Name of the threadpool
*/
protected String name = "TP";
/**
* Sequence.
*/
protected int sequence = 1;
/**
* Thread priority.
*/
protected int threadPriority = Thread.NORM_PRIORITY;
/**
* Constructor.
*/
public ThreadPool() {
maxThreads = MAX_THREADS;
maxSpareThreads = MAX_SPARE_THREADS;
minSpareThreads = MIN_SPARE_THREADS;
currentThreadCount = 0;
currentThreadsBusy = 0;
stopThePool = false;
}
构造函数里面默认指定了线程池配置的东西，这里的每个参数就不说了，tomcat用在这个类里面即对线程池用到的参数使用变量+常量 形式让这个可配置型增加，也好理解修改
构造线程池的策略是什么呢？一个Hashtable来键值对存储
引用
/** The threads that are part of the pool.
* Key is Thread, value is the ControlRunnable
*/
protected Hashtable threads=new Hashtable();
public void addThread( Thread t, ControlRunnable cr ) {
threads.put( t, cr );
for( int i=0; i<listeners.size(); i++ ) {
ThreadPoolListener tpl=(ThreadPoolListener)listeners.elementAt(i);
tpl.threadStart(this, t);
}
}
public void removeThread( Thread t ) {
threads.remove(t);
for( int i=0; i<listeners.size(); i++ ) {
ThreadPoolListener tpl=(ThreadPoolListener)listeners.elementAt(i);
tpl.threadEnd(this, t);
}
}
里面的key经过了多层的包装，他里面封装了很多信息ThreadWithAttributes，这一切都是通过里面的内部类ControlRunnable来实现的，内部类真是个好东西，好多复杂的东西都写在里面，是不是业务逻辑复杂，抽取成方法也不好时，可以考虑抽取内部类
线程池启动时，做一些init工作，主要是把 pool monitor给初始化， adjustLimits()是一个防止你配置错误的validate，如果错误他会有些策略，有兴趣可以看下。完成这一切后。怎么处理线程呢？在newC的时候就
public synchronized void start() {
stopThePool=false;
currentThreadCount = 0;
currentThreadsBusy = 0;
adjustLimits();
pool = new ControlRunnable[maxThreads];
/**这个内部类的构造函数
ControlRunnable(ThreadPool p) {
toRun = null;
shouldTerminate = false;
shouldRun = false;
this.p = p;
t = new ThreadWithAttributes(p, this);
t.setDaemon(true);
t.setName(p.getName() + "-Processor" + p.incSequence());
t.setPriority(p.getThreadPriority());
p.addThread( t, this );
noThData=true;
/**这个start听复杂的，看这运行key的，但可以是ThreadWithAttributes，他继承自Thread，那么它部是空吗？不是在构造方法里面 super(r);这个方法以为着运行目标变成当前类ControlRunnable*/
t.start();
}
创建的数组也并没初始化这个构造函数，有这样一个方法,刚开始直接给你构造好最小个线程
protected void openThreads(int toOpen) {
if(toOpen > maxThreads) {
toOpen = maxThreads;
}
for(int i = currentThreadCount ; i < toOpen ; i++) {
/**居然还是倒着往里面赋值**/
pool[i - currentThreadsBusy] = new ControlRunnable(this);
}
currentThreadCount = toOpen;
}
**/
openThreads(minSpareThreads);
if (maxSpareThreads < maxThreads) {
monitor = new MonitorRunnable(this);
}
}
初始化一切搞定，当线程调用run，那么会去查找相关已经初始化的线程，再取出来，对应去运行
public void run(Runnable r) {
ControlRunnable c = findControlRunnable();
c.runIt(r);
}
那么着就完了吗？tomcat还提供了一个接口，你要使用线程池只需继承它是想相关的东西
/** Implemented if you want to run a piece of code inside a thread pool.
*/
public interface ThreadPoolRunnable {
// XXX use notes or a hashtable-like
// Important: ThreadData in JDK1.2 is implemented as a Hashtable( Thread -> object ),
// expensive.
/** Called when this object is first loaded in the thread pool.
* Important: all workers in a pool must be of the same type,
* otherwise the mechanism becomes more complex.
*/
public Object[] getInitData();
/** This method will be executed in one of the pool's threads. The
* thread will be returned to the pool.
*/
public void runIt(Object thData[]);
}
那么tomcat又在何处使用它了，利用eclipse工具，找到调用类PoolTcpEndpoint，里面的线程是LeaderFollowerWorkerThread还实现了ThreadPoolRunnable，感兴趣可以自己去看看
综上所述，它实现是怎样的，先初始化一定数量的线程，他们都先睡着，线程池 runIt(listener)传入线程，传入后就不notify然后就 shouldRun = true，然后就调用传进来的线程。但是包装的东西好多啊，控制的东西验证的东西也好多，造成了这个类好大。