线程池这个应该是比较重要的一个组件了吧。。。。首先在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<minThreads<maxThreads"); _threads=new HashSet(); //创建用于保存所有线程的集合 _idle=new ArrayList(); //保存空闲的线程的数组 _jobs=new Runnable[_maxThreads]; //用于暂时保存任务 //创建这么多的线程 for (int i=0;i<_minThreads;i++) { newThread(); } }
其实这里做的事情没啥意思,无非就是创建一些集合,数组啥的,然后创建执行线程。。。。
那么来看看这个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; //需要执行的job try { 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--; //减一,因为当前线程会执行一个task job=_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 it if (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) { //如果有空闲的,那么优先用空闲的线程来执行这个task thread=(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不会。。。。。