# -----------------------------------------------------------------------------
# Start Script for the CATALINA Server
# -----------------------------------------------------------------------------

# Better OS/400 detection: see Bugzilla 31132
os400=false
case "`uname`" in
OS400*) os400=true;;
esac

# resolve links - $0 may be a softlink
PRG="$0"

while [ -h "$PRG" ] ; do
  ls=`ls -ld "$PRG"`
  link=`expr "$ls" : '.*-> \(.*\)$'`
  if expr "$link" : '/.*' > /dev/null; then
    PRG="$link"
  else
    PRG=`dirname "$PRG"`/"$link"
  fi
done

PRGDIR=`dirname "$PRG"`
# 将catalina.sh作为可执行程序，后续会调用
EXECUTABLE=catalina.sh

# Check that target executable exists
if $os400; then
  # -x will Only work on the os400 if the files are:
  # 1. owned by the user
  # 2. owned by the PRIMARY group of the user
  # this will not work if the user belongs in secondary groups
  eval
else
  if [ ! -x "$PRGDIR"/"$EXECUTABLE" ]; then
    echo "Cannot find $PRGDIR/$EXECUTABLE"
    echo "The file is absent or does not have execute permission"
    echo "This file is needed to run this program"
    exit 1
  fi
fi

# 调用catalina.sh
exec "$PRGDIR"/"$EXECUTABLE" start "$@"

private static volatile Bootstrap daemon = null;

public static void main(String args[]) {

    synchronized (daemonLock) {
        if (daemon == null) {
            // Don't set daemon until init() has completed
            Bootstrap bootstrap = new Bootstrap();
            try {
                // 执行初始化
                bootstrap.init();
            }

            daemon = bootstrap;
        } else {

            // 设置线程上下文类加载器
            Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
        }
    }

    try {
        // 默认命令是start
        String command = "start";
        // 如果传递了参数，
        if (args.length > 0) {
            // 则将最后一个参数作为命令
            command = args[args.length - 1];
        }

        if (command.equals("startd")) {
            args[args.length - 1] = "start";
            daemon.load(args);
            daemon.start();
        } else if (command.equals("stopd")) {
            args[args.length - 1] = "stop";
            daemon.stop();
        } else if (command.equals("start")) {
            daemon.setAwait(true);
            /*
             * 调用Catalina的load方法，
             * 内部会解析server.xml，这也是load的含义。
             * 在这个过程中会创建各个组件，并设置好父子关系。
             * 注意在add组件的方法中，存在start逻辑，但是要注意getState().isAvailable()返回的是false。
             * 所以在第一次启动的时候，添加组件并不会start组件。
             *
             * 解析完server.xml后，各个组件的创建过程已完成。
             * 接下来就执行从顶层组件Server组件到各个子组件的init操作。
             */
            daemon.load(args);
            /*
             * 调用Catalina的start方法，同样地，也是��顶层组件Server到各个子组件都执行一遍。
             * 从这里可以看出，是先调用init方法再调用start方法。
             */
            daemon.start();
            if (null == daemon.getServer()) {
                System.exit(1);
            }
        } else if (command.equals("stop")) {
            daemon.stopServer(args);
        } else if (command.equals("configtest")) {
            daemon.load(args);
            if (null == daemon.getServer()) {
                System.exit(1);
            }
            System.exit(0);
        } else {
            log.warn("Bootstrap: command \"" + command + "\" does not exist.");
        }
    }

}

public void init(String[] arguments) throws Exception {

    init();
    load(arguments);
}

public void init() throws Exception {

    // 初始化类加载器
    initClassLoaders();
    // 设置线程上下文类加载器
    Thread.currentThread().setContextClassLoader(catalinaLoader);

    SecurityClassLoad.securityClassLoad(catalinaLoader);

    // Load our startup class and call its process() method
    if (log.isDebugEnabled())
        log.debug("Loading startup class");
    // 加载Catalina类
    Class<?> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
    // 创建Catalina对象
    Object startupInstance = startupClass.getConstructor().newInstance();

    // Set the shared extensions class loader
    if (log.isDebugEnabled())
        log.debug("Setting startup class properties");
    String methodName = "setParentClassLoader";
    Class<?> paramTypes[] = new Class[1];
    paramTypes[0] = Class.forName("java.lang.ClassLoader");
    Object paramValues[] = new Object[1];
    // 将sharedLoader作为Catalina对象的parentClassLoader对象
    paramValues[0] = sharedLoader;
    // 获取Catalina中的setParentClassLoader方法
    Method method =
        startupInstance.getClass().getMethod(methodName, paramTypes);
    // 为Catalina对象设置parentClassLoader属性
    method.invoke(startupInstance, paramValues);

    catalinaDaemon = startupInstance;
}

public void load() {

    // 避免重复加载
    if (loaded) {
        return;
    }
    loaded = true;

    long t1 = System.nanoTime();

    // 空操作
    initDirs();

    // Before digester - it may be needed
    // 设置解析配置文件需要的一些属性
    initNaming();

    // Create and execute our Digester
    // 创建配置文件解析器
    Digester digester = createStartDigester();

    InputSource inputSource = null;
    InputStream inputStream = null;
    File file = null;
    try {
        try {
            // 加载server.xml配置文件
            file = configFile();
            // 创建文件流对象
            inputStream = new FileInputStream(file);
            // 将配置文件封装为输入源对象
            inputSource = new InputSource(file.toURI().toURL().toString());
        } catch (Exception e) {
            if (log.isDebugEnabled()) {
                log.debug(sm.getString("catalina.configFail", file), e);
            }
        }

        try {
            /*
             * 通过Digester库解析server.xml
             */
            inputSource.setByteStream(inputStream);
            digester.push(this);
            // 这里会设置this的server属性为StandardServer
            digester.parse(inputSource);
        }

    } finally {

    }

    /*
     * 给server设置catalina属性
     */
    getServer().setCatalina(this);
    // 设置catalina.home属性
    getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile());
    // 设置catalina.base属性
    getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile());

    // Stream redirection
    // 对System的流进行重定向
    initStreams();

    // Start the new server
    try {
        /*
         * 初始化Server对象，为后面的start做准备。
         */
        getServer().init();
    }

}

public void start() {

    // 一般在bootstrap中就已经调用过load()方法了，所以这里不会是null。
    if (getServer() == null) {
        // 初始化server
        load();
    }

    // 确保server组件存在
    if (getServer() == null) {
        log.fatal("Cannot start server. Server instance is not configured.");
        return;
    }

    long t1 = System.nanoTime();

    // Start the new server
    try {
        // 启动server
        getServer().start();
    }

    // Register shutdown hook
    if (useShutdownHook) {
        if (shutdownHook == null) {
            shutdownHook = new CatalinaShutdownHook();
        }
        /*
         * 注册JVM shutdown钩子
         * 将hook对象添加到JVM退出时执行列表中，
         * JVM退出时会执行hook对象的run方法。
         */
        Runtime.getRuntime().addShutdownHook(shutdownHook);

    }

    if (await) {
        // 让当前线程等待Tomcat结束
        await();
        stop();
    }
}

@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
    // 禁用JMX注册
    if (this.disableMBeanRegistry) {
        Registry.disableRegistry();
    }
    // 创建Tomcat实例
    Tomcat tomcat = new Tomcat();
    // 获取或者创建Tomcat的工作目录
    File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
    // 设置工作目录
    tomcat.setBaseDir(baseDir.getAbsolutePath());
    for (LifecycleListener listener : this.serverLifecycleListeners) {
        tomcat.getServer().addLifecycleListener(listener);
    }
    // 创建连接器组件
    Connector connector = new Connector(this.protocol);
    // 设置在失败时抛出异常
    connector.setThrowOnFailure(true);
    // 获取service组件，不存在则会创建，然后添加连接器组件
    tomcat.getService().addConnector(connector);
    // 定制化连接器，会设置监听端口
    customizeConnector(connector);
    // 为tomcat实例设置连接器
    tomcat.setConnector(connector);
    // 获取Host组件，内部会先获取Engine组件，如果不存在则新建；然后设置主机自动部署任务为false
    tomcat.getHost().setAutoDeploy(false);
    // 配置Engine组件
    configureEngine(tomcat.getEngine());
    // 添加额外的连接器组件
    for (Connector additionalConnector : this.additionalTomcatConnectors) {
        tomcat.getService().addConnector(additionalConnector);
    }
    // 创建Tomcat中的Context组件，并设置其属性，然后将其添加到Host组件下
    prepareContext(tomcat.getHost(), initializers);
    // 根据Tomcat实例，创建TomcatWebServer实例对象
    return getTomcatWebServer(tomcat);
}

public Service getService() {
    return getServer().findServices()[0];
}

public Server getServer() {

    // 如果创建过server，
    if (server != null) {
        // 则直接返回
        return server;
    }

    System.setProperty("catalina.useNaming", "false");

    // 创建Server组件
    server = new StandardServer();

    // 初始化工作目录，包括Catalina的base和home目录
    initBaseDir();

    server.setPort( -1 );

    // 创建Service组件
    Service service = new StandardService();
    service.setName("Tomcat");
    // 把service添加到server中
    server.addService(service);
    return server;
}

public Host getHost() {
    // 获取engine组件
    Engine engine = getEngine();
    // 如果存在host子组件，则直接返回
    if (engine.findChildren().length > 0) {
        return (Host) engine.findChildren()[0];
    }

    // 创建host组件
    Host host = new StandardHost();
    host.setName(hostname);
    // 将host组件添加到engine组件中
    getEngine().addChild(host);
    return host;
}

public Engine getEngine() {
    // 获取server中的第一个service组件
    Service service = getServer().findServices()[0];
    if (service.getContainer() != null) {
        return service.getContainer();
    }
    // 创建Engine对象
    Engine engine = new StandardEngine();
    engine.setName( "Tomcat" );
    engine.setDefaultHost(hostname);
    engine.setRealm(createDefaultRealm());
    // 将engine设置到service中
    service.setContainer(engine);
    return engine;
}

protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
    File documentRoot = getValidDocumentRoot();
    // 创建tomcat中的context组件，该类是Spring Boot中实现的，继承tomcat中的StandardContext
    TomcatEmbeddedContext context = new TomcatEmbeddedContext();
    if (documentRoot != null) {
        context.setResources(new LoaderHidingResourceRoot(context));
    }
    // 为context组件设置一些属性
    context.setName(getContextPath());
    context.setDisplayName(getDisplayName());
    context.setPath(getContextPath());
    File docBase = (documentRoot != null) ? documentRoot : createTempDir("tomcat-docbase");
    context.setDocBase(docBase.getAbsolutePath());
    context.addLifecycleListener(new FixContextListener());
    context.setParentClassLoader((this.resourceLoader != null) ? this.resourceLoader.getClassLoader()
            : ClassUtils.getDefaultClassLoader());
    resetDefaultLocaleMapping(context);
    addLocaleMappings(context);
    try {
        context.setCreateUploadTargets(true);
    }
    catch (NoSuchMethodError ex) {
        // Tomcat is < 8.5.39. Continue.
    }
    configureTldPatterns(context);
    WebappLoader loader = new WebappLoader();
    // 设置类加载器名称
    loader.setLoaderClass(TomcatEmbeddedWebappClassLoader.class.getName());
    loader.setDelegate(true);
    // 设置web应用加载器
    context.setLoader(loader);
    // 是否注册默认servlet，该方法默认返回false
    if (isRegisterDefaultServlet()) {
        // 注册默认的servlet
        addDefaultServlet(context);
    }
    // JSP相关
    if (shouldRegisterJspServlet()) {
        addJspServlet(context);
        addJasperInitializer(context);
    }
    // 添加声明周期监听器，用于配置静态资源
    context.addLifecycleListener(new StaticResourceConfigurer(context));
    // 添加一些默认的初始化器，并和上层传递过来的合并在一起
    ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
    // 为host添加context子组件
    host.addChild(context);
    // 将initializers设置到context中
    configureContext(context, initializersToUse);
    // 默认是空操作
    postProcessContext(context);
}

private void initialize() throws WebServerException {
    logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
    synchronized (this.monitor) {
        try {
            addInstanceIdToEngineName();

            Context context = findContext();
            // 添加生命周期监听器
            context.addLifecycleListener((event) -> {
                if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) {
                    // Remove service connectors so that protocol binding doesn't
                    // happen when the service is started.
                    removeServiceConnectors();
                }
            });

            // Start the server to trigger initialization listeners
            /*
             * ==========
             * 启动tomcat
             * ==========
             */
            this.tomcat.start();

            // We can re-throw failure exception directly in the main thread
            rethrowDeferredStartupExceptions();

            try {
                // 绑定类加载器
                ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
            }
            catch (NamingException ex) {
                // Naming is not enabled. Continue
            }

            // Unlike Jetty, all Tomcat threads are daemon threads. We create a
            // blocking non-daemon to stop immediate shutdown
            startDaemonAwaitThread();
        }
        catch (Exception ex) {
            stopSilently();
            destroySilently();
            throw new WebServerException("Unable to start embedded Tomcat", ex);
        }
    }
}

/*
 * SpringBoot中的TomcatWebServer在创建过程中，调用了该类的start()方法。
 */
public void start() throws LifecycleException {
    // 确保Server组件和Service组件存在，如果不存在的话会新建
    getServer();
    // 确保Connector组件存在，如果不存在的话会新建
    getConnector();
    // 从server开始执行各个组件的start操作
    server.start();
}

@Override
public final synchronized void init() throws LifecycleException {
    // 如果组件状态不是NEW，则不能初始化
    if (!state.equals(LifecycleState.NEW)) {
        invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
    }

    try {
        // 设置状态为正在初始化
        setStateInternal(LifecycleState.INITIALIZING, null, false);
        // 调用各个组件的实现
        initInternal();
        // 设置状态为已初始化
        setStateInternal(LifecycleState.INITIALIZED, null, false);
    } catch (Throwable t) {
        handleSubClassException(t, "lifecycleBase.initFail", toString());
    }
}

protected abstract void initInternal() throws LifecycleException;

@Override
protected void initInternal() throws LifecycleException {

    super.initInternal();

    // Register global String cache
    // Note although the cache is global, if there are multiple Servers
    // present in the JVM (may happen when embedding) then the same cache
    // will be registered under multiple names
    onameStringCache = register(new StringCache(), "type=StringCache");

    // Register the MBeanFactory
    MBeanFactory factory = new MBeanFactory();
    factory.setContainer(this);
    onameMBeanFactory = register(factory, "type=MBeanFactory");

    // Register the naming resources
    globalNamingResources.init();

    // Populate the extension validator with JARs from common and shared
    // class loaders
    // 注意内嵌启动的方式，并不会被设置Catalina对象
    if (getCatalina() != null) {
        // 在简化模式下，这里获取到的是commonClassLoader。
        ClassLoader cl = getCatalina().getParentClassLoader();
        // Walk the class loader hierarchy. Stop at the system class loader.
        // This will add the shared (if present) and common class loaders
        while (cl != null && cl != ClassLoader.getSystemClassLoader()) {
            if (cl instanceof URLClassLoader) {
                URL[] urls = ((URLClassLoader) cl).getURLs();
                for (URL url : urls) {
                    if (url.getProtocol().equals("file")) {
                        try {
                            File f = new File (url.toURI());
                            if (f.isFile() &&
                                    f.getName().endsWith(".jar")) {
                                ExtensionValidator.addSystemResource(f);
                            }
                        } catch (URISyntaxException e) {
                            // Ignore
                        } catch (IOException e) {
                            // Ignore
                        }
                    }
                }
            }
            cl = cl.getParent();
        }
    }
    // Initialize our defined Services
    for (Service service : services) {
        /*
         * 初始化Service
         */
        service.init();
    }
}

@Override
protected void startInternal() throws LifecycleException {

    fireLifecycleEvent(CONFIGURE_START_EVENT, null);
    setState(LifecycleState.STARTING);

    globalNamingResources.start();

    // Start our defined Services
    synchronized (servicesLock) {
        // 启动各个Service组件
        for (Service service : services) {
            service.start();
        }
    }
}

@Override
protected void initInternal() throws LifecycleException {

    super.initInternal();

    if (engine != null) {
        // 初始化engine组件
        engine.init();
    }

    // Initialize any Executors
    /*
     * 获取Executor组件，不管是独立启动还是Spring Boot的内嵌启动，这里获取到的executors数量都是0.
     *
     */
    for (Executor executor : findExecutors()) {
        if (executor instanceof JmxEnabled) {
            ((JmxEnabled) executor).setDomain(getDomain());
        }
        // 初始化Executor，StandardThreadExecutor的init方法没有做额外操作
        executor.init();
    }

    // Initialize mapper listener
    // 初始化mapper监听器，没有做额外的操作
    mapperListener.init();

    // Initialize our defined Connectors
    synchronized (connectorsLock) {
        for (Connector connector : connectors) {
            try {
                // 初始化连接器
                connector.init();
            }

        }
    }
}

@Override
protected void startInternal() throws LifecycleException {

    if(log.isInfoEnabled())
        log.info(sm.getString("standardService.start.name", this.name));
    setState(LifecycleState.STARTING);

    // Start our defined Container first
    if (engine != null) {
        synchronized (engine) {
            // 启动engine
            engine.start();
        }
    }

    synchronized (executors) {
        for (Executor executor: executors) {
            // 启动executor，会创建实际的线程池
            executor.start();
        }
    }

    // 启动MapperListener
    mapperListener.start();

    // Start our defined Connectors second
    synchronized (connectorsLock) {
        for (Connector connector: connectors) {
            try {
                // If it has already failed, don't try and start it
                if (connector.getState() != LifecycleState.FAILED) {
                    // 启动connector
                    connector.start();
                }
            }

        }
    }
}

public Connector() {
    this(null);
}


public Connector(String protocol) {
    setProtocol(protocol);
    // Instantiate protocol handler
    ProtocolHandler p = null;
    try {
        // 获取协议处理器类，默认是Http11NioProtocol
        Class<?> clazz = Class.forName(protocolHandlerClassName);
        // 创建协议处理器类
        p = (ProtocolHandler) clazz.getConstructor().newInstance();
    } catch (Exception e) {
        log.error(sm.getString(
                "coyoteConnector.protocolHandlerInstantiationFailed"), e);
    } finally {
        this.protocolHandler = p;
    }

    // 设置字符集
    if (Globals.STRICT_SERVLET_COMPLIANCE) {
        uriCharset = StandardCharsets.ISO_8859_1;
    } else {
        uriCharset = StandardCharsets.UTF_8;
    }

    // Default for Connector depends on this (deprecated) system property
    if (Boolean.parseBoolean(System.getProperty("org.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH", "false"))) {
        encodedSolidusHandling = EncodedSolidusHandling.DECODE;
    }
}

protected String protocolHandlerClassName =
    "org.apache.coyote.http11.Http11NioProtocol";

@Override
protected void initInternal() throws LifecycleException {

    super.initInternal();

    // Initialize adapter
    /*
     * 创建适配器，并传入了this。
     * 在adapter的service方法中，会调用connector通过pipeline完成请求处理。
     */
    adapter = new CoyoteAdapter(this);
    // 给协议处理器设置请求处理适配器
    protocolHandler.setAdapter(adapter);

    // Make sure parseBodyMethodsSet has a default
    if (null == parseBodyMethodsSet) {
        setParseBodyMethods(getParseBodyMethods());
    }

    try {
        // 初始化协议处理器，具体参考AbstractHttp11Protocol及其父类AbstractProtocol。
        protocolHandler.init();
    } catch (Exception e) {
        throw new LifecycleException(
                sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
    }
}

@Override
protected void startInternal() throws LifecycleException {

    // Validate settings before starting
    // 检查端口
    if (getPort() < 0) {
        throw new LifecycleException(sm.getString(
                "coyoteConnector.invalidPort", Integer.valueOf(getPort())));
    }

    setState(LifecycleState.STARTING);

    try {
        /*
         * 启动协议处理器，start方法定义在AbstractProtocol中。
         * 内部会启动Endpoint，对于默认的Http11NioProtocol，endpoint是NioEndpoint类型的。
         */
        protocolHandler.start();
    } catch (Exception e) {
        throw new LifecycleException(
                sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);
    }
}

public StandardEngine() {

    super();
    pipeline.setBasic(new StandardEngineValve());

    // By default, the engine will hold the reloading thread
    backgroundProcessorDelay = 10;

}

@Override
protected void initInternal() throws LifecycleException {
    // Ensure that a Realm is present before any attempt is made to start
    // one. This will create the default NullRealm if necessary.
    // 与安全相关，忽略该组件
    getRealm();
    super.initInternal();
}

@Override
protected void initInternal() throws LifecycleException {
    BlockingQueue<Runnable> startStopQueue = new LinkedBlockingQueue<>();
    // 该线程池的主要作用是用于启动子组件
    startStopExecutor = new ThreadPoolExecutor(
            getStartStopThreadsInternal(),
            getStartStopThreadsInternal(), 10, TimeUnit.SECONDS,
            startStopQueue,
            new StartStopThreadFactory(getName() + "-startStop-"));
    startStopExecutor.allowCoreThreadTimeOut(true);
    super.initInternal();
}

@Override
protected synchronized void startInternal() throws LifecycleException {

    // Log our server identification information
    if(log.isInfoEnabled())
        log.info( "Starting Servlet Engine: " + ServerInfo.getServerInfo());

    // Standard container startup
    super.startInternal();
}

@Override
protected synchronized void startInternal() throws LifecycleException {

    // Start our child containers, if any
    // 获取子组件
    Container children[] = findChildren();
    List<Future<Void>> results = new ArrayList<>();
    // 启动子组件
    for (Container child : children) {
        results.add(startStopExecutor.submit(new StartChild(child)));
    }

    MultiThrowable multiThrowable = null;

    // 遍历各个子组件的启动结果
    for (Future<Void> result : results) {
        try {
            // 等待子组件启动完成
            result.get();
        }

    }

    // Start the Valves in our pipeline (including the basic), if any
    if (pipeline instanceof Lifecycle) {
        // 启动pipeline
        ((Lifecycle) pipeline).start();
    }


    setState(LifecycleState.STARTING);

    // Start our thread
    threadStart();
}

<!--
  minSpareThreads表示核心线程数量，maxThreads表示最大线程数量。
  具体参考StandardThreadExecutor类的startInternal方法。
-->
<Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
    maxThreads="150" minSpareThreads="4"/>

<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           executor="tomcatThreadPool"
/>

@Override
public void begin(String namespace, String name, Attributes attributes)
        throws Exception {
    Service svc = (Service)digester.peek();
    Executor ex = null;
    // 如果配置文件中Connector标签中设置了executor属性
    if ( attributes.getValue("executor")!=null ) {
        ex = svc.getExecutor(attributes.getValue("executor"));
    }
    Connector con = new Connector(attributes.getValue("protocol"));
    if (ex != null) {
        // 设置线程池
        setExecutor(con, ex);
    }
    String sslImplementationName = attributes.getValue("sslImplementationName");
    if (sslImplementationName != null) {
        setSSLImplementationName(con, sslImplementationName);
    }
    digester.push(con);
}

private static void setExecutor(Connector con, Executor ex) throws Exception {
    // 获取到Connector的协议处理器类中的setExecutor方法
    Method m = IntrospectionUtils.findMethod(con.getProtocolHandler().getClass(),"setExecutor",new Class[] {java.util.concurrent.Executor.class});
    if (m!=null) {
        // 反射调用方法来设置线程池
        m.invoke(con.getProtocolHandler(), new Object[] {ex});
    }else {
        log.warn(sm.getString("connector.noSetExecutor", con));
    }
}

// ---------------------------------------------- Properties
/**
 * Default thread priority
 */
protected int threadPriority = Thread.NORM_PRIORITY;

/**
 * Run threads in daemon or non-daemon state
 */
protected boolean daemon = true;

/**
 * Default name prefix for the thread name
 */
protected String namePrefix = "tomcat-exec-";

/**
 * max number of threads
 */
protected int maxThreads = 200;

/**
 * min number of threads
 */
protected int minSpareThreads = 25;

/**
 * idle time in milliseconds
 */
protected int maxIdleTime = 60000;

/**
 * The executor we use for this component
 */
protected ThreadPoolExecutor executor = null;

/**
 * the name of this thread pool
 */
protected String name;

/**
 * prestart threads?
 */
protected boolean prestartminSpareThreads = false;

/**
 * The maximum number of elements that can queue up before we reject them
 */
protected int maxQueueSize = Integer.MAX_VALUE;

/**
 * After a context is stopped, threads in the pool are renewed. To avoid
 * renewing all threads at the same time, this delay is observed between 2
 * threads being renewed.
 */
protected long threadRenewalDelay =
    org.apache.tomcat.util.threads.Constants.DEFAULT_THREAD_RENEWAL_DELAY;

private TaskQueue taskqueue = null;

@Override
protected void startInternal() throws LifecycleException {

    // 创建任务队列
    taskqueue = new TaskQueue(maxQueueSize);
    // 创建线程工厂
    TaskThreadFactory tf = new TaskThreadFactory(namePrefix,daemon,getThreadPriority());
    /*
     * 创建线程池，这里的ThreadPoolExecutor和JDK的类同名，是对后者的封装。
     * 默认是25个核心线程，200个最大线程，非核心线程最长空闲时长为60秒。
     */
    executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), maxIdleTime, TimeUnit.MILLISECONDS,taskqueue, tf);
    executor.setThreadRenewalDelay(threadRenewalDelay);
    // 这个属性默认是false，表示不预先启动核心线程
    if (prestartminSpareThreads) {
        // 预启动核心线程
        executor.prestartAllCoreThreads();
    }
    // 为任务队列绑定执行器
    taskqueue.setParent(executor);

    setState(LifecycleState.STARTING);
}

public Http11NioProtocol() {
    /*
     * 创建NioEndPoint对象，并传入父类构造器。
     */
    super(new NioEndpoint());
}

@Override
public void init() throws Exception {
    // Upgrade protocols have to be configured first since the endpoint
    // init (triggered via super.init() below) uses this list to configure
    // the list of ALPN protocols to advertise
    // 协议升级相关
    for (UpgradeProtocol upgradeProtocol : upgradeProtocols) {
        configureUpgradeProtocol(upgradeProtocol);
    }

    // 会初始化端点组件
    super.init();
}

public String getName() {
    return ObjectName.quote(getNameInternal());
}

private String getNameInternal() {
    // 这里考虑Http11NioProtocol中的getNamePrefix方法，返回的是http-nio
    StringBuilder name = new StringBuilder(getNamePrefix());
    name.append('-');
    // 如果设置了主机地址
    if (getAddress() != null) {
        // 获取主机地址
        name.append(getAddress().getHostAddress());
        name.append('-');
    }
    // 获取端口
    int port = getPort();
    // 如果端口是0
    if (port == 0) {
        // Auto binding is in use. Check if port is known
        name.append("auto-");
        name.append(getNameIndex());
        port = getLocalPort();
        if (port != -1) {
            name.append('-');
            name.append(port);
        }
    } else {
        // 追加上端口，如最常见的http-nio-8080
        name.append(port);
    }
    return name.toString();
}

protected abstract String getNamePrefix();

@Override
public void start() throws Exception {
    if (getLog().isInfoEnabled()) {
        getLog().info(sm.getString("abstractProtocolHandler.start", getName()));
    }

    // 启动端点组件，参考NioEndpoint
    endpoint.start();

    // Start timeout thread
    asyncTimeout = new AsyncTimeout();
    // 创建线程，周期性处理异步超时相关任务。
    Thread timeoutThread = new Thread(asyncTimeout, getNameInternal() + "-AsyncTimeout");
    int priority = endpoint.getThreadPriority();
    if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
        priority = Thread.NORM_PRIORITY;
    }
    timeoutThread.setPriority(priority);
    timeoutThread.setDaemon(true);
    // 启动线程
    timeoutThread.start();
}

protected Adapter adapter;
@Override
public void setAdapter(Adapter adapter) { this.adapter = adapter; }
@Override
public Adapter getAdapter() { return adapter; }

@Override
public void init() throws Exception {
    // 测试加密套件
    testServerCipherSuitesOrderSupport();
    super.init();
}

private NioSelectorPool selectorPool = new NioSelectorPool();