Tomcat源码阅读之闭锁的实现与连接数量的控制

嗯，今天其实在看HtttpProcessor的实现，但是突然想到了以前在看poller的时候看到了有闭锁，用于控制当前connector的连接数量，嗯，那就顺便把这部分来看了。。。

在Tomcat中，通过继承AbstractQueuedSynchronizer来实现了自己的同步工具，进而来实现了一个用于控制连接数量的闭锁。。LimitLatch。。

这里就需对AbstractQueuedSynchronizer有一些初步的了解。。。

首先它concurrent类库中提供的一个用于构建自己的同步工具的一个工具类。。可以通过继承他来快速的完成一个同步类的实现

（1）acquireSharedInterruptibly（）方法，用于以共享的方式来获取锁，如果暂时无法获取，将会将线程挂起到队列，进行阻塞，对于这个方法是否最终能获取锁，是通过tryAcquireShared（）方法的返回来定义的，这个方法需要自己实现。。。如果能获取锁，那么返回1，否则返回-1.。。

（2）releaseShared（）方法。以共享的方法释放一个锁，这样前面提到的挂起的线程将会唤醒，进而重新尝试获取锁。。。

好啦，接下来就来看看LimitLatch的定义吧，直接上代码好了，。，。代码还是很简单的。。

//其实是通过AbstractQueuedSynchronizer来构建的
public class LimitLatch {

    private static final Log log = LogFactory.getLog(LimitLatch.class);

    //构建Sync类型，实现基本的同步，以及阻塞。。
    private class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1L;

        public Sync() {
        }

        @Override
        //用于增加计数，如果计数增加之后小于最大的，那么返回1，不会阻塞，否则将会返回-1阻塞
        protected int tryAcquireShared(int ignored) {  //调用acquiredShared方法的时候会调用这个方法来返回状态，如果返回1，那么表示获取成功，返回-1表示获取失败，将会阻塞
            long newCount = count.incrementAndGet();  //先增加计数
            if (!released && newCount > limit) {  //如果当前已经超过了最大的限制
                // Limit exceeded
                count.decrementAndGet();  //减少计数
                return -1;  //返回-1，将阻塞当前线程
            } else {
                return 1;
            }
        }

        @Override
        //用于减少计数
        protected boolean tryReleaseShared(int arg) {
            count.decrementAndGet();
            return true;
        }
    }

    private final Sync sync;  //同步对象
    private final AtomicLong count;  //计数器
    private volatile long limit;  //最大的数量
    private volatile boolean released = false;   //是否全部释放

    /**
     * Instantiates a LimitLatch object with an initial limit.
     * @param limit - maximum number of concurrent acquisitions of this latch
     */
    public LimitLatch(long limit) {
        this.limit = limit;  //最大限制
        this.count = new AtomicLong(0);
        this.sync = new Sync();  //sync 对象
    }

    /**
     * Returns the current count for the latch
     * @return the current count for latch
     */
    public long getCount() {
        return count.get();
    }

    /**
     * Obtain the current limit.
     */
    public long getLimit() {
        return limit;
    }


    /**
     * Sets a new limit. If the limit is decreased there may be a period where
     * more shares of the latch are acquired than the limit. In this case no
     * more shares of the latch will be issued until sufficient shares have been
     * returned to reduce the number of acquired shares of the latch to below
     * the new limit. If the limit is increased, threads currently in the queue
     * may not be issued one of the newly available shares until the next
     * request is made for a latch.
     *
     * @param limit The new limit
     */
    public void setLimit(long limit) {
        this.limit = limit;
    }


    /**
     * Acquires a shared latch if one is available or waits for one if no shared
     * latch is current available.
     */
    //增加计数，如果太大，那么等等待
    public void countUpOrAwait() throws InterruptedException {
        if (log.isDebugEnabled()) {
            log.debug("Counting up["+Thread.currentThread().getName()+"] latch="+getCount());
        }
        sync.acquireSharedInterruptibly(1);
    }

    /**
     * Releases a shared latch, making it available for another thread to use.
     * @return the previous counter value
     */
    //减少计数
    public long countDown() {
        sync.releaseShared(0);  //释放
        long result = getCount();
        if (log.isDebugEnabled()) {
            log.debug("Counting down["+Thread.currentThread().getName()+"] latch="+result);
    }
        return result;
    }

    /**
     * Releases all waiting threads and causes the {@link #limit} to be ignored
     * until {@link #reset()} is called.
     */
    //通过将released设置为true，将会释放所有的线程，知道reset了
    public boolean releaseAll() {
        released = true;
        return sync.releaseShared(0);
    }

    /**
     * Resets the latch and initializes the shared acquisition counter to zero.
     * @see #releaseAll()
     */
    //重制
    public void reset() {
        this.count.set(0);
        released = false;
    }

    /**
     * Returns <code>true</code> if there is at least one thread waiting to
     * acquire the shared lock, otherwise returns <code>false</code>.
     */
    //当前是否有线程等待
    public boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    /**
     * Provide access to the list of threads waiting to acquire this limited
     * shared latch.
     */
    //获取所有等待的线程
    public Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }
}

代码应该还是很简单的吧，而且注释也算是说的比较清楚。。。其实是构建了一个继承自AbstractQueuedSynchronizer的Sync对象，通过它来进行真正的同步功能。。。然后通过一个原子的整数计数器，和一个最大值，来判断当前是否可以获取锁

好啦，这里来看看Tomcat是如何通过LimitLatch来控制连接数量的吧，先来看看NioEndpoint的启动方法：

    //启动当前的endpoint
    public void startInternal() throws Exception {

        if (!running) {
            running = true;  //设置表示为，表示已经看是运行了
            paused = false;  //没有暂停

            // Create worker collection
            if ( getExecutor() == null ) {  //如果没有executor，那么创建
                createExecutor();   //创建executor
            }

            initializeConnectionLatch();   //初始化闭锁，用于控制连接的数量

            // Start poller threads
            pollers = new Poller[getPollerThreadCount()];   //根据设置的poller数量来创建poller对象的数组
            for (int i=0; i<pollers.length; i++) {
                pollers[i] = new Poller();  // 创建poller对象
                Thread pollerThread = new Thread(pollers[i], getName() + "-ClientPoller-"+i);  // 创建相应的poller线程
                pollerThread.setPriority(threadPriority);
                pollerThread.setDaemon(true);
                pollerThread.start();  //启动poller
            }

            startAcceptorThreads();  //启动acceptor
        }
    }

这里调用了initializeConnectionLatch方法来初始化闭锁，来看看吧：

    //初始化闭锁，用于控制连接的数量
    protected LimitLatch initializeConnectionLatch() {
        if (maxConnections==-1) return null;  //这个是无限的链接数量
        if (connectionLimitLatch==null) {
            connectionLimitLatch = new LimitLatch(getMaxConnections());  //根据最大的链接数量来创建
        }
        return connectionLimitLatch;
    }

我们知道在Connector的配置中可以设置最大的链接数量，其实这里也就是通过这个数量来构建LimitLatch对象的。。。

嗯，Tomcat是从哪里获取连接呢，这个就要从Accecptor看了。。。

 public void run() {

            int errorDelay = 0;

            // Loop until we receive a shutdown command
            while (running) {

                // Loop if endpoint is paused
                while (paused && running) {  //如果暂停了
                    state = AcceptorState.PAUSED;  //更改当前acceptor的状态
                    try {
                        Thread.sleep(50);  
                    } catch (InterruptedException e) {
                        // Ignore
                    }
                }

                if (!running) {  //如果没有运行，那么这里直接跳过
                    break;
                }
                state = AcceptorState.RUNNING;  //设置当前acceptor的状态是running

                try {
                    //if we have reached max connections, wait
                    countUpOrAwaitConnection();  //增减闭锁的计数，如果connection数量已经达到了最大，那么暂停一下，这里用到的是connectionLimitLatch锁，可以理解为一个闭锁吧

                    SocketChannel socket = null;
                    try {
                        // Accept the next incoming connection from the server
                        // socket
                        socket = serverSock.accept();  //调用serversocket的accept方法
                    } catch (IOException ioe) {
                        //we didn't get a socket
                        countDownConnection();  //出了异常，并没有获取链接，那么这里减少闭锁的计数
                        // Introduce delay if necessary
                        errorDelay = handleExceptionWithDelay(errorDelay);
                        // re-throw
                        throw ioe;
                    }
                    // Successful accept, reset the error delay
                    errorDelay = 0;

                    // setSocketOptions() will add channel to the poller
                    // if successful
                    if (running && !paused) {
                        if (!setSocketOptions(socket)) {  //这里主要是将socket加入到poller对象上面去，而且还要设置参数
                            countDownConnection();  //加入poller对象失败了的话，那么将闭锁的计数减低
                            closeSocket(socket);  //关闭刚刚 创建的这个socket
                        }
                    } else {
                        countDownConnection();
                        closeSocket(socket);
                    }
                } catch (SocketTimeoutException sx) {
                    // Ignore: Normal condition
                } catch (IOException x) {
                    if (running) {
                        log.error(sm.getString("endpoint.accept.fail"), x);
                    }
                } catch (OutOfMemoryError oom) {
                    try {
                        oomParachuteData = null;
                        releaseCaches();
                        log.error("", oom);
                    }catch ( Throwable oomt ) {
                        try {
                            try {
                                System.err.println(oomParachuteMsg);
                                oomt.printStackTrace();
                            }catch (Throwable letsHopeWeDontGetHere){
                                ExceptionUtils.handleThrowable(letsHopeWeDontGetHere);
                            }
                        }catch (Throwable letsHopeWeDontGetHere){
                            ExceptionUtils.handleThrowable(letsHopeWeDontGetHere);
                        }
                    }
                } catch (Throwable t) {
                    ExceptionUtils.handleThrowable(t);
                    log.error(sm.getString("endpoint.accept.fail"), t);
                }
            }
            state = AcceptorState.ENDED;  //设置acceptor的状态为ended
        }

这里读一下Accecptor，的run方法可以知道，每次在调用serverSocketChannel的accept方法之前都会调用countUpOrAwaitConnection方法来增加闭锁的计数，如果有问题，那就会调用countDownConnection方法来降低闭锁的计数。。。

其实这里通过这两个方法就知道他们是干嘛的了，先来看看countUpOrAwaitConnection吧：

    //这里用于增加闭锁的计数
    protected void countUpOrAwaitConnection() throws InterruptedException {
        if (maxConnections==-1) return;
        LimitLatch latch = connectionLimitLatch;
        if (latch!=null) latch.countUpOrAwait();  //增加闭锁的counter
    }

没啥意思吧，就是调用刚刚创建的闭锁的countUpOrAwait方法，接下来来看看countDownConnection方法吧：

    //用于减少闭锁的计数
    protected long countDownConnection() {
        if (maxConnections==-1) return -1;
        LimitLatch latch = connectionLimitLatch;
        if (latch!=null) {
            long result = latch.countDown();
            if (result<0) {
                getLog().warn("Incorrect connection count, multiple socket.close called on the same socket." );
            }
            return result;
        } else return -1;
    }

这个也没啥意思吧。。。就是调用闭锁的countDown方法。。。

嗯，到这里整个Tomcat如何控制连接的数量就算是比较清楚了吧。。。

最后，我们知道是通过调用endpoint的cancelledKey方法来关闭一个连接的，来看看它的实现吧：

     //取消一个注册
        public void cancelledKey(SelectionKey key, SocketStatus status) {
            try {
                if ( key == null ) return;//nothing to do
                KeyAttachment ka = (KeyAttachment) key.attachment();
                if (ka != null && ka.isComet() && status != null) {
                    ka.setComet(false);//to avoid a loop
                    if (status == SocketStatus.TIMEOUT ) {
                        if (processSocket(ka.getChannel(), status, true)) {
                            return; // don't close on comet timeout
                        }
                    } else {
                        // Don't dispatch if the lines below are canceling the key
                        processSocket(ka.getChannel(), status, false);
                    }
                }
                key.attach(null);  //将附件设置为null
                if (ka!=null) handler.release(ka);  //可以取消这个attachment了
                else handler.release((SocketChannel)key.channel());
                if (key.isValid()) key.cancel();  //取消key
                if (key.channel().isOpen()) {  //如果channel还是打开的，那么需要关闭channel
                    try {
                        key.channel().close();
                    } catch (Exception e) {
                        if (log.isDebugEnabled()) {
                            log.debug(sm.getString(
                                    "endpoint.debug.channelCloseFail"), e);
                        }
                    }
                }
                try {
                    if (ka!=null) {
                        ka.getSocket().close(true); //关闭sockt
                    }
                } catch (Exception e){
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString(
                                "endpoint.debug.socketCloseFail"), e);
                    }
                }
                try {
                    if (ka != null && ka.getSendfileData() != null
                            && ka.getSendfileData().fchannel != null
                            && ka.getSendfileData().fchannel.isOpen()) {
                        ka.getSendfileData().fchannel.close();
                    }
                } catch (Exception ignore) {
                }
                if (ka!=null) {
                    ka.reset();
                    countDownConnection();  //降低用于维护连接数量的闭锁
                }
            } catch (Throwable e) {
                ExceptionUtils.handleThrowable(e);
                if (log.isDebugEnabled()) log.error("",e);
            }
        }

这里可以看到调用了countDownConnection方法来降低闭锁的计数。。

最后总结：Tomcat通过在acceptor中对闭锁的获取来控制总连接的数量，如果连接数量达到了最大的限制，那么将会被阻塞。。直到有连接关闭为止。。。这样acceptor的线程就又被唤醒了。。。