jetty的线程池实现QueuedThreadPool
线程池这个应该是比较重要的一个组件了吧。。。。首先在SelectChannelConnector中，需要建立SelectSet，从而建立selector，而select的执以及I/O的都需要放到线程池中运行，而且需要独占的线程。。
而当selector中获取远程连接的数据之后，就需要进行http的处理流程。。。这里又需要将他们派发到线程池中运行。。。
从而线程池实现的高效也是jetty是否能够高效的执行的关键。。。。
不过其实总体来说jetty的线程池的实现还是很简单的。。。。常用的就是QueuedThreadPool。。
也没啥继承，本来还以为要用到concurrent里面线程的。。
好了，先来看看他的一些属性申明吧：
private String _name;private Set _threads; //当前所有的线程的集合private List _idle; //保存空闲的线程private Runnable[] _jobs; //一个数组,用于保存提交的task，将其用成了循环队列private int _nextJob; //下一个要执行的线程的位置private int _nextJobSlot; //可以用来存放提交的任务的位置private int _queued; //已经放了多少任务到jobs数组中，等待被执行private int _maxQueued; //最大private boolean _daemon; //是否要将线程设置为后台线程private int _id;//三个锁，_lock用于保护线程池公用的数据，例如queued，jobs啥的，private final Object _lock = new Lock();private final Object _threadsLock = new Lock();private final Object _joinLock = new Lock();private long _lastShrink; //表示上一次线程空闲的时间private int _maxIdleTimeMs=60000; //最大空闲时间是一分钟啊，还挺长的private int _maxThreads=250; //最大线程数量。。我擦。。居然这么多private int _minThreads=2; //最小线程数量 。。感觉这些默认的属性值都不靠谱啊在private boolean _warned=false; //如果当前服务器太忙了，它会被设置private int _lowThreads=0; //低水平的线程适量private int _priority= Thread.NORM_PRIORITY; //线程优先级private int _spawnOrShrinkAt=0; //最多能够将这么多任务放到任务队列中，如果太多了，那么应该启动更多的线程去执行,这个一般都会在外面被设置private int _maxStopTimeMs;这里比较重要的就是几个数组吧，首先是threads，它是一个集合，用于保存现在拥有的所有线程。。。
其次是idle数组，这个用于保存空闲的线程。。。。
再其次就是job数组了，它用于保存提交的任务。。如果不能立即找到空闲的线程来执行的话，那么就先暂时将其派发到数组里面去
好了，接下来来看看 doStart方法吧，。。。看看当前线程池是怎么启动的。。。
//启动当前的线程池，protected void doStart() throws Exception {if (_maxThreads<_minThreads || _minThreads<=0)throw new IllegalArgumentException("!0其实这里做的事情没啥意思，无非就是创建一些集合，数组啥的，然后创建执行线程。。。。
那么来看看这个newThread方法做了什么事情吧：
//创建线程的方法protected void newThread() {synchronized (_threadsLock) {if (_threads.size()<_maxThreads) { //如果还没有到达最大线程PoolThread thread =new PoolThread(); //创建一个执行线程_threads.add(thread); //将刚刚创建的线程保存到集合中去thread.setName(thread.hashCode()+"@"+_name+"-"+_id++);thread.start(); //启动这个线程} else if (!_warned) { //否则就表示创建的线程已经到了最大数量了。。那么当前服务器太忙了_warned=true;Log.debug("Max threads for {}",this);}}}好吧，还是没啥意思，这里面又真正的创建执行线程PoolThread，它是当前类型的内部类，然后在将其设置到threads数组里面，最后在启动它。。
那么我们接下来来看看这个PoolThread的定义吧：
//执行线程的定义public class PoolThread extends Thread {Runnable _job=null;PoolThread() {setDaemon(_daemon); //这里是否要设置为后台线程要看外面的设置情况setPriority(_priority);}//执行函数public void run() {boolean idle=false; //刚开始肯定默认 没有空闲Runnable job=null; //需要执行的jobtry {while (isRunning()) { //首先要判断当前线程池还在运行// Run any job that we have.if (job!=null) {final Runnable todo=job;job=null;idle=false;todo.run();}synchronized(_lock) {// is there a queued job?if (_queued>0) { //表示数组里面还有线程需要执行_queued--; //减一，因为当前线程会执行一个taskjob=_jobs[_nextJob++]; //获取 这个任务if (_nextJob==_jobs.length)_nextJob=0; //循环数组的操作continue; //直接continue，那么就会执行刚刚取出来的任务了}// Should we shrink?final int threads=_threads.size(); //当前线程的总数量if (threads>_minThreads && (threads>_maxThreads || _idle.size()>_spawnOrShrinkAt)) {long now = System.currentTimeMillis();if ((now-_lastShrink)>getMaxIdleTimeMs()) { //空闲时间太长了，而且线程太多了，那么需要退出一些线程_lastShrink=now;_idle.remove(this);return;}}if (!idle) { //表示当前线程空闲了_idle.add(this); //将他们放到空闲数组里面去idle=true; //表示已经空闲了}}synchronized (this) {if (_job==null) {this.wait(getMaxIdleTimeMs()); //阻塞这么长的时间，有可能会超时唤醒，也有可能会被外面唤醒 }job=_job;_job=null;}}}catch (InterruptedException e){Log.ignore(e);}finally{synchronized (_lock){_idle.remove(this);}synchronized (_threadsLock){_threads.remove(this);}synchronized (this){job=_job;}// we died with a job! reschedule itif (job!=null){QueuedThreadPool.this.dispatch(job);}}}/* ------------------------------------------------------------ */void dispatch(Runnable job) { //外面直接提交task给这个线程，那么会唤醒它synchronized (this) {_job=job; //this.notify(); //唤醒当前的阻塞}}}private class Lock{}
}
其实这个很简单吧，run方法也很简单就能够理解，首先判断当前的jobs数组里面是否有需要执行的task，如果有的话，那么取出来一个任务执行，如果没有的话，那么就表示没有可以执行的任务了，那么就需要将其放到数组空闲数组里面去了（当然这里还会判断线程是否过多，以及空闲时间太长，有可能执行线程直接就退出了），，然后调用wait方法阻塞当前线程。。。它有可能因为超时而唤醒，也有可能因为外面又task需要执行了而被唤醒。。。
好了。。那么执行线程还是比较简单的吧。。。接着看看外面线程池的dispatch方法是怎么定义的吧：
//将提交的任务调度执行public boolean dispatch(Runnable job) { if (!isRunning() || job==null)return false;PoolThread thread=null;boolean spawn=false;synchronized(_lock) {int idle=_idle.size(); //当前空闲线程数组的大小if (idle>0) { //如果有空闲的，那么优先用空闲的线程来执行这个taskthread=(PoolThread)_idle.remove(idle-1);} else { //如果没有空闲的线程，那么需要将这个任务暂时保存下来，等到有线程空闲下来之后会拿去执行_queued++; //这里增加已经保存的任务的数量if (_queued>_maxQueued) {_maxQueued=_queued;}_jobs[_nextJobSlot++]=job;if (_nextJobSlot==_jobs.length) {_nextJobSlot=0; //这还是一个循环数组}if (_nextJobSlot==_nextJob) { //这里表示数组里面已经存满了要执行的任务Runnable[] jobs= new Runnable[_jobs.length+_maxThreads]; //那么需要扩充数组了int split=_jobs.length-_nextJob;//复制，这里居然还考虑了保持原来任务的执行顺序。。呵呵。。是我的话就不管了，直接复制好了if (split>0)System.arraycopy(_jobs,_nextJob,jobs,0,split); if (_nextJob!=0)System.arraycopy(_jobs,0,jobs,split,_nextJobSlot);_jobs=jobs;_nextJob=0;_nextJobSlot=_queued;}spawn=_queued>_spawnOrShrinkAt; //存放的线程时候已经太多了}}if (thread!=null) {thread.dispatch(job); //如果有空闲的线程，那么由这个线程来哦执行} else if (spawn) { //如果延迟太厉害，那么需要再创建新的线程newThread();}return true;}这个其实也很简单吧，无非是先看空闲的线程数组里是否有空闲的线程，如果有的话，那么直接唤醒它，由它来执行，如果没有的话就将其放到jobs队列当中去。。。这里还会判断当前job是否太多了。。有可能会创建新的执行线程。。。
到这里总体上jetty的线程池的实现就算差不多了。。很简单。。不过也还算不错吧。。。
与netty的线程池实现略有不同，这里所有的执行线程共享一个任务队列，而在netty中每一个执行线程自己都有自己的job队列。。从而在jetty中线程间的负载均衡看起来就简单的多了。。。。而netty中就比较二，只能轮询的将task交给执行线程。。。不过netty之所以这么实现也是有原因的，因为要实现线程封闭性。。。
另外jetty的线程池中线程的数量会根据服务器的繁忙程度更改，但是netty不会。。。。。
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！