Tomcat源码解析(三)：LifeCycle生命周期管理

2025-07-22 15:14:12

Tomcat源码解析(三)：LifeCycle生命周期管理 Tomcat源码系列文章Tomcat源码解析(一)：Tomcat整体架构Tomcat源码解析(二)：Bootstrap和CatalinaTomcat源码解析(三)：LifeCycle生命周期管理前言在前文中我们介绍了tomcat的启动类加载核心内容就是getServer().init()组件的初始化和getServer().start()

Tomcat源码解析(三)：LifeCycle生命周期管理

Tomcat源码系列文章

Tomcat源码解析(一)：Tomcat整体架构

Tomcat源码解析(二)：Bootstrap和Catalina

Tomcat源码解析(三)：LifeCycle生命周期管理

前言

在前文中我们介绍了tomcat的启动类加载
核心内容就是getServer().init()组件的初始化和getServer().start()启动服务
由于所有的组件均存在初始化、启动、停止等生命周期方法，拥有生命周期管理的特性
基于生命周期管理抽象成了一个接口Lifecycle
组件Server、Service、Container、Executor、Connector组件，都实现生命周期的接口

一、LifeCycle接口

1、接口介绍

LifeCycle接口内容可以分为三类：处理、生命周期方法、生命周期状态
各个组件都有个生命周期状态，在执行生命周期方法后产生变化，可以通过getState方法来获取
一个组件在状态变化时可以通过被注册在其上的触发一些处理操作

代码语言：javascript代码运行次数：0运行复制

public interface Lifecycle {
    /** 第1类：处理 **/
    // 添加
    public void addLifecycleListener(LifecycleListener listener);
    // 获取所以
    public LifecycleListener[] findLifecycleListeners();
    // 移除某个
    public void removeLifecycleListener(LifecycleListener listener);
    
    /** 第2类：生命周期方法 **/
    // 初始化方法
    public void init() throws LifecycleException;
    // 启动方法
    public void start() throws LifecycleException;
    // 停止方法，和start对应
    public void stop() throws LifecycleException;
    // 销毁方法，和init对应
    public void destroy() throws LifecycleException;
    
    /** 第类：生命周期状态 **/
    // 获取生命周期状态
    public LifecycleState getState();
    // 获取字符串类型的生命周期状态
    public String getStateame();
}

2、生命周期状态

在枚举类LifecycleState里Tomcat给各个组件定义了一些生命周期中的状态
每个状态都有一个lifecycleEvent参数，在的时候会用到

代码语言：javascript代码运行次数：0运行复制

public enum LifecycleState {
	// 容器刚刚创建时，即在LifecycleBase实例构造完成时的状态
    EW(false, null),
    // 容器初始化过程中的状态
    IITIALIZIG(false, Lifecycle.BEFORE_IIT_EVET),
    // 容器初始化完成时的状态
    IITIALIZED(false, Lifecycle.AFTER_IIT_EVET),
    // 容器启动前的状态
    STARTIG_PREP(false, Lifecycle.BEFORE_START_EVET),
    // 容器启动过程中的状态
    STARTIG(true, Lifecycle.START_EVET),
    // 容器启动完成的状态
    STARTED(true, Lifecycle.AFTER_START_EVET),
    // 容器停止前的状态
    STOPPIG_PREP(true, Lifecycle.BEFORE_STOP_EVET),
    // 容器停止过程中的状态
    STOPPIG(false, Lifecycle.STOP_EVET),
    // 容器停止完成的状态
    STOPPED(false, Lifecycle.AFTER_STOP_EVET),
    // 容器销毁过程中的状态
    DESTROYIG(false, Lifecycle.BEFORE_DESTROY_EVET),
    // 容器销毁后的状态
    DESTROYED(false, Lifecycle.AFTER_DESTROY_EVET),
    // 容器启动、停止过程中出现异常的状态
    FAILED(false, null);
 
    private final boolean available;
    private final String lifecycleEvent;
 
    LifecycleState(boolean available, String lifecycleEvent) {
        this.available = available;
        this.lifecycleEvent = lifecycleEvent;
    }
 
    public boolean isAvailable() {
        return available;
    }
 
    public String getLifecycleEvent() {
        return lifecycleEvent;
    }
}

这些状态主要用于对组件进行管控，现在只需要知道这些组件都有自己的生命周期状态且可以进行转换即可

特别说明：所有的状态都可以可以转换为FAILED状态

二、LifecycleBase抽象类

LifecycleBase抽象类是Lifecycle接口的基本实现

1、

生命周期保存在一个线程安全的CopyOnWriteArrayList中
所以add和remove都是直接调用此List的相应方法
findLifecycleListeners方法：返回的是一个数组，为了线程安全，所以这儿会生成一个新数组
fireLifecycleEvent方法：允许子类触发生命周期事件

代码语言：javascript代码运行次数：0运行复制

public abstract class LifecycleBase implements Lifecycle {
	// 已注册的事件通知的列表
	private final List<LifecycleListener> lifecycleListeners = new CopyOnWriteArrayList<>();
	 
	@Override
	public void addLifecycleListener(LifecycleListener listener) {
	    lifecycleListeners.add(listener);
	}
	@Override
	public LifecycleListener[] findLifecycleListeners() {
	    return (new LifecycleListener[0]);
	}
	@Override
	public void removeLifecycleListener(LifecycleListener listener) {
	    lifecycleListeners.remove(listener);
	}
	
	// 触发生命周期事件
	protected void fireLifecycleEvent(String type, Object data) {
	    LifecycleEvent event = new LifecycleEvent(this, type, data);
	    for (LifecycleListener listener : lifecycleListeners) {
	        listener.lifecycleEvent(event);
	    }
	}
}

2、init

基本流程就是状态切换，切换过程中的具体操作留给子类（即我们的各个组件如server、service等）去实现

代码语言：javascript代码运行次数：0运行复制

@Override
public final synchronized void init() throws LifecycleException {
    // 非EW状态，不允许调用init()方法
    if (!(LifecycleState.EW)) {
    	// 抛出异常
        invalidTransition(Lifecycle.BEFORE_IIT_EVET);
    }
 
    try {
        // 初始化逻辑之前，先将状态变更为`IITIALIZIG（初始化过程中状态）`
        setStateInternal(LifecycleState.IITIALIZIG, null, false);
        // 初始化，该方法为一个abstract方法，需要组件自行实现
        initInternal();
        // 初始化完成之后，状态变更为`IITIALIZED（初始化完成状态）`
        setStateInternal(LifecycleState.IITIALIZED, null, false);
    } catch (Throwable t) {
        // 初始化的过程中，可能会有异常抛出，这时需要捕获异常，并将状态变更为`FAILED（异常状态）`
        ExceptionUtils.handleThrowable(t);
        setStateInternal(LifecycleState.FAILED, null, false);
        throw new LifecycleException(
                sm.getString("lifecycleBase.initFail",toString()), t);
    }
}
// 真正的初始化方法，需要子类实现此方法
protected abstract void initInternal() throws LifecycleException;

setStateInternal方法用于维护状态，同时在状态转换成功之后触发事件
为了状态的可见性，所以state声明为volatile类型的

代码语言：javascript代码运行次数：0运行复制

private volatile LifecycleState state = LifecycleState.EW;。
 
private synchronized void setStateInternal(LifecycleState state,
        Object data, boolean check) throws LifecycleException {
    // 是否校验状态，一般初始化启动流程这里都是false
    if (check) {
        // state不允许为null
        if (state == null) {
        	// 抛异常
            invalidTransition("null");
            return;
        }
        if (!(state == LifecycleState.FAILED ||
                (this.state == LifecycleState.STARTIG_PREP &&
                        state == LifecycleState.STARTIG) ||
                (this.state == LifecycleState.STOPPIG_PREP &&
                        state == LifecycleState.STOPPIG) ||
                (this.state == LifecycleState.FAILED &&
                        state == LifecycleState.STOPPIG))) {
            invalidTransition(());
        }
    }
    // 设置状态
    this.state = state;
    // 触发事件
    String lifecycleEvent = state.getLifecycleEvent();
    if (lifecycleEvent != null) {
        fireLifecycleEvent(lifecycleEvent, data);
    }
}

设置完 state 的状态之后，就触发该状态的事件了，通知事件
这里的LifecycleListener对象是在Catalina对象解析server.xml文件时就已经创建好并加到lifecycleListeners里的

代码语言：javascript代码运行次数：0运行复制

private final List<LifecycleListener> lifecycleListeners = new CopyOnWriteArrayList<>();
 
protected void fireLifecycleEvent(String type, Object data) {
    LifecycleEvent event = new LifecycleEvent(this, type, data);
    for (LifecycleListener listener : lifecycleListeners) {
        listener.lifecycleEvent(event);
    }
}

、start

start和init类似，先做校验后切换状态，具体start操作留给子类实现

代码语言：javascript代码运行次数：0运行复制

public final synchronized void start() throws LifecycleException {
    // `STARTIG_PREP启动前`、`STARTIG启动中`和`STARTED启动完成时，将忽略start()逻辑
    if (LifecycleState.STARTIG_(state) || LifecycleState.(state) ||
            LifecycleState.(state)) {
        return;
    }
 
    // `EW`状态时，执行init()方法
    if ((LifecycleState.EW)) {
        init();
    }
 
    // `FAILED`状态时，执行stop()方法
    else if ((LifecycleState.FAILED)) {
        stop();
    }
 
    // 不是`IITIALIZED初始化完成`和`STOPPED停止完成`时，则说明是非法的操作
    else if (!(LifecycleState.IITIALIZED) &&
            !(LifecycleState.STOPPED)) {
        // 抛出异常
        invalidTransition(Lifecycle.BEFORE_START_EVET);
    }
 
 	// 一般流程会走到这里，刚走完初始化流程，状态为IITIALIZED（初始化完成状态）
    try {
        // start前的状态设置
        setStateInternal(LifecycleState.STARTIG_PREP, null, false);
        // start逻辑，抽象方法，由组件自行实现
        startInternal();
        // start过程中，可能因为某些原因失败，这时需要stop操作
        if ((LifecycleState.FAILED)) {
            stop();
        } else if (!(LifecycleState.STARTIG)) {
        	// 抛出异常
            invalidTransition(Lifecycle.AFTER_START_EVET);
        } else {
            // 设置状态为STARTED（启动完成状态）
            setStateInternal(LifecycleState.STARTED, null, false);
        }
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        // 异常状态
        setStateInternal(LifecycleState.FAILED, null, false);
        throw new LifecycleException(sm.getString("lifecycleBase.startFail", toString()), t);
    }
}

4、stop

stop和start类似，先做校验后切换状态，具体stop操作留给子类实现

代码语言：javascript代码运行次数：0运行复制

@Override
public final synchronized void stop() throws LifecycleException {
    // `STOPPIG_PREP停止前`、`STOPPIG停止中`和STOPPED停止完成时，将忽略stop()的执行
    if (LifecycleState.STOPPIG_(state) || LifecycleState.(state) ||
            LifecycleState.(state)) {

        if (log.isDebugEnabled()) {
            Exception e = new LifecycleException();
            log.debug(sm.getString("lifecycleBase.alreadyStopped", toString()), e);
        } else if (log.isInfoEnabled()) {
            log.info(sm.getString("lifecycleBase.alreadyStopped", toString()));
        }
        return;
    }

    // `EW`状态时，直接将状态变更为`STOPPED`
    if ((LifecycleState.EW)) {
        state = LifecycleState.STOPPED;
        return;
    }

    // stop()的执行，必须要是`STARTED`和`FAILED`
    if (!(LifecycleState.STARTED) && !(LifecycleState.FAILED)) {
        invalidTransition(Lifecycle.BEFORE_STOP_EVET);
    }

 	// 一般流程会走到这里，走完启动流程，状态为STARTED（启动完成状态）
    try {
        // `FAILED`时，直接触发BEFORE_STOP_EVET事件
        if ((LifecycleState.FAILED)) {
            fireLifecycleEvent(BEFORE_STOP_EVET, null);
        } 
        // 设置状态为STOPPIG_PREP（停止前）
        else {
            setStateInternal(LifecycleState.STOPPIG_PREP, null, false);
        }

        // stop逻辑，抽象方法，组件自行实现
        stopInternal();

        // 如果不是停止中状态也不是异常状态，则抛出异常
        if (!(LifecycleState.STOPPIG) && !(LifecycleState.FAILED)) {
            invalidTransition(Lifecycle.AFTER_STOP_EVET);
        }
        // 设置状态为STOPPED（停止完成）
        setStateInternal(LifecycleState.STOPPED, null, false);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        setStateInternal(LifecycleState.FAILED, null, false);
        throw new LifecycleException(sm.getString("lifecycleBase.stopFail",toString()), t);
    } finally {
        if (this instanceof Lifecycle.SingleUse) {
            // 设置状态为STOPPED（停止完成）
            setStateInternal(LifecycleState.STOPPED, null, false);
            destroy();
        }
    }
}

5、destroy

destroy和stop类似，先做校验后切换状态，具体destroy操作留给子类实现

代码语言：javascript代码运行次数：0运行复制

@Override
public final synchronized void destroy() throws LifecycleException {
    // `FAILED`状态时，直接触发stop()逻辑
    if (LifecycleState.(state)) {
        try {
            // Triggers clean-up
            stop();
        } catch (LifecycleException e) {
            // Just log. Still want to destroy.
            log.warn(sm.getString(
                    "lifecycleBase.destroyStopFail", toString()), e);
        }
    }

    // `DESTROYIG`和`DESTROYED`时，忽略destroy的执行
    if (LifecycleState.(state) ||
            LifecycleState.(state)) {

        if (log.isDebugEnabled()) {
            Exception e = new LifecycleException();
            log.debug(sm.getString("lifecycleBase.alreadyDestroyed", toString()), e);
        } else if (log.isInfoEnabled() && !(this instanceof Lifecycle.SingleUse)) {
            // Rather than have every component that might need to call
            // destroy() check for SingleUse, don't log an info message if
            // multiple calls are made to destroy()
            log.info(sm.getString("lifecycleBase.alreadyDestroyed", toString()));
        }
        return;
    }

    // 非法状态判断
    if (!(LifecycleState.STOPPED) &&
            !(LifecycleState.FAILED) &&
            !(LifecycleState.EW) &&
            !(LifecycleState.IITIALIZED)) {
        invalidTransition(Lifecycle.BEFORE_DESTROY_EVET);
    }

    try {
        // destroy前状态设置
        setStateInternal(LifecycleState.DESTROYIG, null, false);
       // 抽象方法，组件自行实现
        destroyInternal();
        // destroy后状态设置
        setStateInternal(LifecycleState.DESTROYED, null, false);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        setStateInternal(LifecycleState.FAILED, null, false);
        throw new LifecycleException(
                sm.getString("lifecycleBase.destroyFail",toString()), t);
    }
}

总结

为了统一管理组件的初始化、启动、停止、销毁方法，抽象出生命周期接口Lifecycle
LifecycleBase是使用模板模式来实现，具体操作留给子类，抽象模板方法如下

代码语言：javascript代码运行次数：0运行复制

// 初始化方法
protected abstract void initInternal() throws LifecycleException;
// 启动方法
protected abstract void startInternal() throws LifecycleException;
// 停止方法
protected abstract void stopInternal() throws LifecycleException;
// 销毁方法
protected abstract void destroyInternal() throws LifecycleException;

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。原始发表：2024-04-01，如有侵权请联系 cloudcommunity@tencent 删除生命周期源码tomcatlifecycle管理

#感谢您对电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格的认可，转载请说明来源于"电脑配置推荐网 - 最新i3 i5 i7组装电脑配置单推荐报价格

本文地址：http://www.dnpztj.cn/biancheng/1161379.html

本站网友孕妇水肿	20分钟前发表
则说明是非法的操作 else if (!(LifecycleState.IITIALIZED) && !(LifecycleState.STOPPED)) { // 抛出异常 invalidTransition(Lifecycle.BEFORE_START_EVET); } // 一般流程会走到这里
本站网友花样年别样城	12分钟前发表
type
本站网友溪黄草的功效	28分钟前发表
t); } } // 真正的初始化方法
本站网友黑话	17分钟前发表
生命周期状态各个组件都有个生命周期状态
本站网友尼日尔首都	2分钟前发表
具体操作留给子类
本站网友尼斯	23分钟前发表
data); } }设置完 state 的状态之后
本站网友胃康灵	11分钟前发表
t); } } // 真正的初始化方法
本站网友谍报	11分钟前发表
Lifecycle.AFTER_IIT_EVET)
本站网友抗菌素分类	13分钟前发表
null); private final boolean available; private final String lifecycleEvent; LifecycleState(boolean available
本站网友马来酸氯苯那敏	18分钟前发表
null
本站网友世硕	15分钟前发表
null
本站网友天津限价房申请条件	24分钟前发表
原始发表：2024-04-01
本站网友败酱草	2分钟前发表
通知事件这里的LifecycleListener对象是在Catalina对象解析server.xml文件时就已经创建好并加到lifecycleListeners里的代码语言：javascript代码运行次数：0运行复制private final List<LifecycleListener> lifecycleListeners = new CopyOnWriteArrayList<>(); protected void fireLifecycleEvent(String type
本站网友什么杀毒软件最好用	17分钟前发表
null)
本站网友最新的消息	22分钟前发表
e); } else if (log.isInfoEnabled()) { log.info(sm.getString("lifecycleBase.alreadyStopped"

Tomcat源码解析(三)：LifeCycle生命周期管理