1.server的启动

前面我们说过了,server的启动过程主要是通过catalina进行一个启动,而在启动过程中他又经历了哪些过程呢?

从代码中看,server的启动过程中,他继承了lifecycleMbeanBase这个类并且实现了接口server,

而在这lifecycleMbeanBase类中又继承了LifecycleBase这个类,并且LifecycleBase复写了他父接口其中的initInternal和startInter这两个方法,这两个方法是一个模板方法。

server的启动过程中还有一个重要的方法叫做await方法,就是catalina就是调用他进入到了等待状态,进入到了等待状态,其中

// Negative values - don't wait on port - tomcat is embedded or we just don't like ports
        if( port == -2 ) {
            // undocumented yet - for embedding apps that are around, alive.
            return;
        }
        if( port==-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(port, 1,
                    InetAddress.getByName(address));
        } catch (IOException e) {
            log.error("StandardServer.await: create[" + address
                               + ":" + port
                               + "]: ", 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("StandardServer.accept security exception: "
                                + ace.getMessage(), ace);
                        continue;
                    } catch (IOException e) {
                        if (stopAwait) {
                            // Wait was aborted with socket.close()
                            break;
                        }
                        log.error("StandardServer.await: accept: ", 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("StandardServer.await: read: ", 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("StandardServer.await: Invalid command '"
                            + command.toString() + "' received");
            }
        } finally {
            ServerSocket serverSocket = awaitSocket;
            awaitThread = null;
            awaitSocket = null;

// Close the server socket and return
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    // Ignore
                }
            }
        }
    这个方法中写着,当Tomcat的端口为-2时则直接退出等待状态,关闭Tomcat,如果为-1时则会一直循环,当stopAwait为图二时才会停止,而当为其他端口时,也会进入一个循环,这个循环可以跳出,有break,当指定的端口监听到shutdown一样的命令时,Tomcat就会关闭。

2.service的启动过程。

service也实现了LifecycleMBeanBase这个方法,从里面

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 (container != null) {
            synchronized (container) {
                container.start();
            }
        }

synchronized (executors) {
            for (Executor executor: executors) {
                executor.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.start();
                    }
                } catch (Exception e) {
                    log.error(sm.getString(
                            "standardService.connector.startFailed",
                            connector), e);
                }
            }
        }
    }

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 (container != null) {
            synchronized (container) {
                container.start();
            }
        }

synchronized (executors) {
            for (Executor executor: executors) {
                executor.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.start();
                    }
                } catch (Exception e) {
                    log.error(sm.getString(
                            "standardService.connector.startFailed",
                            connector), e);
                }
            }
        }
    }

从他的初始化方法和start方法中可以看出来,他调用用了container,executors,connector等组件。其中container也就是我们说的container容器,executors是是executor的线程池,

<!--The connectors can use a shared executor, you can define one or more named thread pools-->
    <!--
    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
        maxThreads="150" minSpareThreads="4"/>
    -->
这个线程池最多能够启用150个,最少四个线程。这样整个Tomcat就启动了。下面这个图片是转载的。大概就是这么个过程、

Tomcat的server启动相关推荐

  1. Tomcat(二):tomcat配置文件server.xml详解和部署简介

    1. 入门示例:虚拟主机提供web服务 该示例通过设置虚拟主机来提供web服务,因为是入门示例,所以设置极其简单,只需修改$CATALINA_HOME/conf/server.xml文件为如下内容即可 ...

  2. tomcat配置文件server.xml具体解释

    元素名 属性 解释 server port 指定一个port,这个port负责监听关闭tomcat 的请求 shutdown 指定向port发送的命令字符串 service name 指定servic ...

  3. JVM Client Server启动设置

    看看你下面的这两个文件,是不是尺寸差别很大? %JAVA_HOME%/jre/bin/client/jvm.dll %JAVA_HOME%/jre/bin/server/jvm.dll    Jvm动 ...

  4. eclipse中tomcat启动不了_Spring Boot中Tomcat是怎么启动的

    Spring Boot一个非常突出的优点就是不需要我们额外再部署Servlet容器,它内置了多种容器的支持.我们可以通过配置来指定我们需要的容器. 本文以我们平时最常使用的容器Tomcat为列来介绍以 ...

  5. 理解Tomcat架构、启动流程及其性能优化

    PS:but, it's bullshit ! 备注:实话说,从文档上扒拉的,文档地址:在每一个Tomcat安装目录下,会有一个webapps文件夹,里面有一个docs文件夹,点击index.html ...

  6. Tomcat 的 Server 文件配置详解

    转载自  Tomcat 的 Server 文件配置详解 前言 Tomcat隶属于Apache基金会,是开源的轻量级Web应用服务器,使用非常广泛.server.xml是Tomcat中最重要的配置文件, ...

  7. linux主机熵值过小,tomcat在linux启动应用慢解决方式

    问题: o.a.c.util.SessionIdGeneratorBase - Creation of SecureRandom instance for session ID generation ...

  8. Eureka Server启动源码分析

    本文来分析下Eureka Server启动源码 文章目录 概述 源码解析 服务同步 服务剔除 start包配置 启动源码分析 EurekaServerAutoConfiguration EurekaS ...

  9. tomcat 9 无法启动_运维常见问题汇总tomcat篇

    tomcat介绍 Tomcat 服务器是一个开源的轻量级Web应用服务器,在中小型系统和并发量小的场合下被普遍使用,是开发和调试Servlet.JSP 程序的首选. #tomcat 运行环境介绍 1. ...

最新文章

  1. ES6新增的let与const
  2. 查看mysql是否启动_Mysql查看是否使用到索引
  3. 论文笔记之:End-to-End Localization and Ranking for Relative Attributes
  4. Cochrane系统综述注册的具体流程
  5. 图解Tomcat类加载机制(阿里面试题)
  6. 51单片机实现三位十进制数加减乘除运算
  7. mockito mock void方法_一文让你快速上手 Mockito 单元测试框架
  8. Django 新建account应用
  9. Python机器学习:梯度下降法001什么是梯度下降法
  10. @Scheduled cron表达式
  11. ThinkPHP 数据库操作,插入,更新,删除,查询
  12. 抄答案就是了,两套详细的设计方案,解决头疼的支付掉单问题
  13. python找不到tushare_python stock数据包tushare
  14. Retrofit使用小结
  15. 如何合并多个excel表
  16. rjs 合并压缩完 js 后 js 不压缩的问题
  17. 暗黑-角色-中英文对照
  18. 工具箱@CMD实用命令
  19. 自然语言处理NLP文本分类顶会论文阅读笔记(二)
  20. 【华为OD机试真题 python】最短木板长度【2022 Q4 | 100分】

热门文章

  1. [ web 漏洞篇 ] 常见web漏洞总结之 RCE 远程代码 / 命令执行漏洞总结
  2. vue使用ts 引入组件_vue中使用TS实现父子组件直接的通信
  3. CorelDRAW Graphics Suite 2022
  4. 20个经典管理学定律
  5. 基于python的国内外研究现状怎么写_国内外研究现状的写法
  6. 什么是高性能计算,涉及哪些技术和知识呢?
  7. 【产品分享】嘉为蓝鲸统一告警中心,系统可用的第一层保障!
  8. 基于Modis数据监测森林火灾
  9. Linux命令date命令
  10. 嵌入式课程---嵌入式Linux的直流电机驱动开发