Tomcat Server的设计和实现：StandardServer详解

<server port="8005" shutdown="shutdown">
  <!-- 1.属性说明
    port:指定一个端口，这个端口负责监听关闭tomcat的请求
    shutdown:向以上端口发送的关闭服务器的命令字符串
  -->
  <!-- 2.listener 相关 -->
  <listener classname="org.apache.catalina.core.aprlifecyclelistener" />
  <listener classname="org.apache.catalina.mbeans.serverlifecyclelistener" />
  <listener classname="org.apache.catalina.mbeans.globalresourceslifecyclelistener" />
  <listener classname="org.apache.catalina.storeconfig.storeconfiglifecyclelistener"/>
  <!-- 3.globalnamingresources 相关 -->
  <globalnamingresources>
    <environment name="simplevalue" type="java.lang.integer" value="30"/>
    <resource name="userdatabase" auth="container"
              type="org.apache.catalina.userdatabase"
       description="user database that can be updated and saved"
           factory="org.apache.catalina.users.memoryuserdatabasefactory"
          pathname="conf/tomcat-users.xml" />
  </globalnamingresources>
  <!-- 4.service 相关 -->
  <service name="catalina">
  </service>
</server>

/**
  * @return the port number we listen to for shutdown commands.
  *
  * @see #getportoffset()
  * @see #getportwithoffset()
  */
public int getport();
/**
  * set the port number we listen to for shutdown commands.
  *
  * @param port the new port number
  *
  * @see #setportoffset(int)
  */
public void setport(int port);
/**
  * get the number that offsets the port used for shutdown commands.
  * for example, if port is 8005, and portoffset is 1000,
  * the server listens at 9005.
  *
  * @return the port offset
  */
public int getportoffset();
/**
  * set the number that offsets the server port used for shutdown commands.
  * for example, if port is 8005, and you set portoffset to 1000,
  * connector listens at 9005.
  *
  * @param portoffset sets the port offset
  */
public void setportoffset(int portoffset);
/**
  * get the actual port on which server is listening for the shutdown commands.
  * if you do not set port offset, port is returned. if you set
  * port offset, port offset + port is returned.
  *
  * @return the port with offset
  */
public int getportwithoffset();
/**
  * @return the address on which we listen to for shutdown commands.
  */
public string getaddress();
/**
  * set the address on which we listen to for shutdown commands.
  *
  * @param address the new address
  */
public void setaddress(string address);
/**
  * @return the shutdown command string we are waiting for.
  */
public string getshutdown();
/**
  * set the shutdown command we are waiting for.
  *
  * @param shutdown the new shutdown command
  */
public void setshutdown(string shutdown);
/**
  * get the utility thread count.
  * @return the thread count
  */
public int getutilitythreads();
/**
  * set the utility thread count.
  * @param utilitythreads the new thread count
  */
public void setutilitythreads(int utilitythreads);

/**
  * @return the global naming resources.
  */
public namingresourcesimpl getglobalnamingresources();
/**
  * set the global naming resources.
  *
  * @param globalnamingresources the new global naming resources
  */
public void setglobalnamingresources
    (namingresourcesimpl globalnamingresources);
/**
  * @return the global naming resources context.
  */
public javax.naming.context getglobalnamingcontext();

/**
  * add a new service to the set of defined services.
  *
  * @param service the service to be added
  */
public void addservice(service service);
/**
  * wait until a proper shutdown command is received, then return.
  */
public void await();
/**
  * find the specified service
  *
  * @param name name of the service to be returned
  * @return the specified service, or <code>null</code> if none exists.
  */
public service findservice(string name);
/**
  * @return the set of services defined within this server.
  */
public service[] findservices();
/**
  * remove the specified service from the set associated from this
  * server.
  *
  * @param service the service to be removed
  */
public void removeservice(service service);

// 此service中用于各种实用程序任务（包括重复执行的线程）的线程数
@override
public int getutilitythreads() {
    return utilitythreads;
}
/**
  * 获取内部进程数计算逻辑：
  * > 0时，即utilitythreads的值。
  * <=0时，runtime.getruntime().availableprocessors() + result...
  */
private static int getutilitythreadsinternal(int utilitythreads) {
    int result = utilitythreads;
    if (result <= 0) {
        result = runtime.getruntime().availableprocessors() + result;
        if (result < 2) {
            result = 2;
        }
    }
    return result;
}
@override
public void setutilitythreads(int utilitythreads) {
    // use local copies to ensure thread safety
    int oldutilitythreads = this.utilitythreads;
    if (getutilitythreadsinternal(utilitythreads) < getutilitythreadsinternal(oldutilitythreads)) {
        return;
    }
    this.utilitythreads = utilitythreads;
    if (oldutilitythreads != utilitythreads && utilityexecutor != null) {
        reconfigureutilityexecutor(getutilitythreadsinternal(utilitythreads));
    }
}
// 线程池
private synchronized void reconfigureutilityexecutor(int threads) {
    // the scheduledthreadpoolexecutor doesn't use maximumpoolsize, only corepoolsize is available
    if (utilityexecutor != null) {
        utilityexecutor.setcorepoolsize(threads);
    } else {
        scheduledthreadpoolexecutor scheduledthreadpoolexecutor =
                new scheduledthreadpoolexecutor(threads,
                        new taskthreadfactory("catalina-utility-", utilitythreadsasdaemon, thread.min_priority));
        scheduledthreadpoolexecutor.setkeepalivetime(10, timeunit.seconds);
        scheduledthreadpoolexecutor.setremoveoncancelpolicy(true);
        scheduledthreadpoolexecutor.setexecuteexistingdelayedtasksaftershutdownpolicy(false);
        utilityexecutor = scheduledthreadpoolexecutor;
        utilityexecutorwrapper = new org.apache.tomcat.util.threads.scheduledthreadpoolexecutor(utilityexecutor);
    }
}
/**
  * get if the utility threads are daemon threads.
  * @return the threads daemon flag
  */
public boolean getutilitythreadsasdaemon() {
    return utilitythreadsasdaemon;
}
/**
  * set the utility threads daemon flag. the default value is true.
  * @param utilitythreadsasdaemon the new thread daemon flag
  */
public void setutilitythreadsasdaemon(boolean utilitythreadsasdaemon) {
    this.utilitythreadsasdaemon = utilitythreadsasdaemon;
}

/**
  * add a new service to the set of defined services.
  *
  * @param service the service to be added
  */
@override
public void addservice(service service) {
    service.setserver(this);
    synchronized (serviceslock) {
        service results[] = new service[services.length + 1];
        system.arraycopy(services, 0, results, 0, services.length);
        results[services.length] = service;
        services = results;
        if (getstate().isavailable()) {
            try {
                service.start();
            } catch (lifecycleexception e) {
                // ignore
            }
        }
        // report this property change to interested listeners
        support.firepropertychange("service", null, service);
    }
}
public void stopawait() {
    stopawait=true;
    thread t = awaitthread;
    if (t != null) {
        serversocket s = awaitsocket;
        if (s != null) {
            awaitsocket = null;
            try {
                s.close();
            } catch (ioexception e) {
                // ignored
            }
        }
        t.interrupt();
        try {
            t.join(1000);
        } catch (interruptedexception e) {
            // ignored
        }
    }
}
/**
  * wait until a proper shutdown command is received, then return.
  * this keeps the main thread alive - the thread pool listening for http
  * connections is daemon threads.
  */
@override
public void await() {
    // negative values - don't wait on port - tomcat is embedded or we just don't like ports
    if (getportwithoffset() == -2) {
        // undocumented yet - for embedding apps that are around, alive.
        return;
    }
    if (getportwithoffset() == -1) {
        try {
            awaitthread = thread.currentthread();
            while(!stopawait) {
                try {
                    thread.sleep( 10000 );
                } catch( interruptedexception ex ) {
                    // continue and check the flag
                }
            }
        } finally {
            awaitthread = null;
        }
        return;
    }
    // set up a server socket to wait on
    try {
        awaitsocket = new serversocket(getportwithoffset(), 1,
                inetaddress.getbyname(address));
    } catch (ioexception e) {
        log.error(sm.getstring("standardserver.awaitsocket.fail", address,
                string.valueof(getportwithoffset()), string.valueof(getport()),
                string.valueof(getportoffset())), e);
        return;
    }
    try {
        awaitthread = thread.currentthread();
        // loop waiting for a connection and a valid command
        while (!stopawait) {
            serversocket serversocket = awaitsocket;
            if (serversocket == null) {
                break;
            }
            // wait for the next connection
            socket socket = null;
            stringbuilder command = new stringbuilder();
            try {
                inputstream stream;
                long acceptstarttime = system.currenttimemillis();
                try {
                    socket = serversocket.accept();
                    socket.setsotimeout(10 * 1000);  // ten seconds
                    stream = socket.getinputstream();
                } catch (sockettimeoutexception ste) {
                    // this should never happen but bug 56684 suggests that
                    // it does.
                    log.warn(sm.getstring("standardserver.accept.timeout",
                            long.valueof(system.currenttimemillis() - acceptstarttime)), ste);
                    continue;
                } catch (accesscontrolexception ace) {
                    log.warn(sm.getstring("standardserver.accept.security"), ace);
                    continue;
                } catch (ioexception e) {
                    if (stopawait) {
                        // wait was aborted with socket.close()
                        break;
                    }
                    log.error(sm.getstring("standardserver.accept.error"), e);
                    break;
                }
                // read a set of characters from the socket
                int expected = 1024; // cut off to avoid dos attack
                while (expected < shutdown.length()) {
                    if (random == null)
                        random = new random();
                    expected += (random.nextint() % 1024);
                }
                while (expected > 0) {
                    int ch = -1;
                    try {
                        ch = stream.read();
                    } catch (ioexception e) {
                        log.warn(sm.getstring("standardserver.accept.readerror"), e);
                        ch = -1;
                    }
                    // control character or eof (-1) terminates loop
                    if (ch < 32 || ch == 127) {
                        break;
                    }
                    command.append((char) ch);
                    expected--;
                }
            } finally {
                // close the socket now that we are done with it
                try {
                    if (socket != null) {
                        socket.close();
                    }
                } catch (ioexception e) {
                    // ignore
                }
            }
            // match against our command string
            boolean match = command.tostring().equals(shutdown);
            if (match) {
                log.info(sm.getstring("standardserver.shutdownviaport"));
                break;
            } else
                log.warn(sm.getstring("standardserver.invalidshutdowncommand", command.tostring()));
        }
    } finally {
        serversocket serversocket = awaitsocket;
        awaitthread = null;
        awaitsocket = null;
        // close the server socket and return
        if (serversocket != null) {
            try {
                serversocket.close();
            } catch (ioexception e) {
                // ignore
            }
        }
    }
}
/**
  * @return the specified service (if it exists); otherwise return
  * <code>null</code>.
  *
  * @param name name of the service to be returned
  */
@override
public service findservice(string name) {
    if (name == null) {
        return null;
    }
    synchronized (serviceslock) {
        for (service service : services) {
            if (name.equals(service.getname())) {
                return service;
            }
        }
    }
    return null;
}
/**
  * @return the set of services defined within this server.
  */
@override
public service[] findservices() {
    return services;
}
/**
  * @return the jmx service names.
  */
public objectname[] getservicenames() {
    objectname onames[]=new objectname[ services.length ];
    for( int i=0; i<services.length; i++ ) {
        onames[i]=((standardservice)services[i]).getobjectname();
    }
    return onames;
}
/**
  * remove the specified service from the set associated from this
  * server.
  *
  * @param service the service to be removed
  */
@override
public void removeservice(service service) {
    synchronized (serviceslock) {
        int j = -1;
        for (int i = 0; i < services.length; i++) {
            if (service == services[i]) {
                j = i;
                break;
            }
        }
        if (j < 0)
            return;
        try {
            services[j].stop();
        } catch (lifecycleexception e) {
            // ignore
        }
        int k = 0;
        service results[] = new service[services.length - 1];
        for (int i = 0; i < services.length; i++) {
            if (i != j)
                results[k++] = services[i];
        }
        services = results;
        // report this property change to interested listeners
        support.firepropertychange("service", service, null);
    }
}

/**
 * start nested components ({@link service}s) and implement the requirements
 * of {@link org.apache.catalina.util.lifecyclebase#startinternal()}.
 *
 * @exception lifecycleexception if this component detects a fatal error
 *  that prevents this component from being used
 */
@override
protected void startinternal() throws lifecycleexception {
    firelifecycleevent(configure_start_event, null);
    setstate(lifecyclestate.starting);
    globalnamingresources.start();
    // start our defined services
    synchronized (serviceslock) {
        for (int i = 0; i < services.length; i++) {
            services[i].start();
        }
    }
    if (periodiceventdelay > 0) {
        monitorfuture = getutilityexecutor().schedulewithfixeddelay(
                new runnable() {
                    @override
                    public void run() {
                        startperiodiclifecycleevent();
                    }
                }, 0, 60, timeunit.seconds);
    }
}
protected void startperiodiclifecycleevent() {
    if (periodiclifecycleeventfuture == null || (periodiclifecycleeventfuture != null && periodiclifecycleeventfuture.isdone())) {
        if (periodiclifecycleeventfuture != null && periodiclifecycleeventfuture.isdone()) {
            // there was an error executing the scheduled task, get it and log it
            try {
                periodiclifecycleeventfuture.get();
            } catch (interruptedexception | executionexception e) {
                log.error(sm.getstring("standardserver.periodiceventerror"), e);
            }
        }
        periodiclifecycleeventfuture = getutilityexecutor().scheduleatfixedrate(
                new runnable() {
                    @override
                    public void run() {
                        firelifecycleevent(lifecycle.periodic_event, null);
                    }
                }, periodiceventdelay, periodiceventdelay, timeunit.seconds);
    }
}