import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
public void setMaxConnections(int maxCon) {
    this.maxConnections = maxCon;
    LimitLatch latch = this.connectionLimitLatch;
    if (latch != null) {
        // Update the latch that enforces this
        if (maxCon == -1) {
            releaseConnectionLatch();
        } else {
            latch.setLimit(maxCon);
        }
    } else if (maxCon > 0) {
        initializeConnectionLatch();
    }
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
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;
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
public void setMaxConnections(int maxCon) {
	this.maxConnections = maxCon;
	LimitLatch latch = this.connectionLimitLatch;
	if (latch != null) {
		// Update the latch that enforces this
		if (maxCon == -1) {
			releaseConnectionLatch();
		} else {
			latch.setLimit(maxCon);
		}
	} else if (maxCon > 0) {
		initializeConnectionLatch();
	}
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
protected void countUpOrAwaitConnection() throws InterruptedException {
	if (maxConnections == -1)
		return;
	LimitLatch latch = connectionLimitLatch;
	if (latch != null)
		latch.countUpOrAwait();
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
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;
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
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;
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
public void setMaxConnections(int maxCon) {
    this.maxConnections = maxCon;
    LimitLatch latch = this.connectionLimitLatch;
    if (latch != null) {
        // Update the latch that enforces this
        latch.setLimit(maxCon);
    }
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
protected long countDownConnection() {
    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;
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
protected void releaseConnectionLatch() {
    LimitLatch latch = connectionLimitLatch;
    if (latch!=null) latch.releaseAll();
    connectionLimitLatch = null;
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
protected void countUpOrAwaitConnection() throws InterruptedException {
    if (maxConnections==-1) return;
    LimitLatch latch = connectionLimitLatch;
    if (latch!=null) latch.countUpOrAwait();
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
protected void countUpOrAwaitConnection() throws InterruptedException {
    // 无限连接
    if (maxConnections==-1) return;
    LimitLatch latch = connectionLimitLatch;
    if (latch!=null) latch.countUpOrAwait();
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
protected void releaseConnectionLatch() {
	LimitLatch latch = connectionLimitLatch;
	if (latch != null)
		latch.releaseAll();
	connectionLimitLatch = null;
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
protected void countUpOrAwaitConnection() throws InterruptedException {
    LimitLatch latch = connectionLimitLatch;
    if (latch!=null) latch.countUpOrAwait();
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
/**
 * Return the current count of connections handled by this endpoint, if the
 * connections are counted (which happens when the maximum count of
 * connections is limited), or <code>-1</code> if they are not. This
 * property is added here so that this value can be inspected through JMX.
 * It is visible on "ThreadPool" MBean.
 *
 * <p>The count is incremented by the Acceptor before it tries to accept a
 * new connection. Until the limit is reached and thus the count cannot be
 * incremented,  this value is more by 1 (the count of acceptors) than the
 * actual count of connections that are being served.
 *
 * @return The count
 */
public long getConnectionCount() {
    LimitLatch latch = connectionLimitLatch;
    if (latch != null) {
        return latch.getCount();
    }
    return -1;
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
/**
 * Return the current count of connections handled by this endpoint, if the
 * connections are counted (which happens when the maximum count of
 * connections is limited), or <code>-1</code> if they are not. This
 * property is added here so that this value can be inspected through JMX.
 * It is visible on "ThreadPool" MBean.
 *
 * <p>
 * The count is incremented by the Acceptor before it tries to accept a new
 * connection. Until the limit is reached and thus the count cannot be
 * incremented, this value is more by 1 (the count of acceptors) than the
 * actual count of connections that are being served.
 *
 * @return The count
 */
public long getConnectionCount() {
	LimitLatch latch = connectionLimitLatch;
	if (latch != null) {
		return latch.getCount();
	}
	return -1;
}
 

import org.apache.tomcat.util.threads.LimitLatch; //导入依赖的package包/类
/**
 * Return the current count of connections handled by this endpoint, if the
 * connections are counted (which happens when the maximum count of
 * connections is limited), or <code>-1</code> if they are not. This
 * property is added here so that this value can be inspected through JMX.
 * It is visible on "ThreadPool" MBean.
 * <p>
 * The count is incremented by the Acceptor before it tries to accept a new
 * connection. Until the limit is reached and thus the count cannot be
 * incremented, this value is more by 1 (the count of acceptors) than the
 * actual count of connections that are being served.
 *
 * @return The count
 */
public long getConnectionCount() {
	LimitLatch latch = connectionLimitLatch;
	if (latch != null) {
		return latch.getCount();
	}
	return -1;
}