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

冬天vs不冷

发布于 2025-01-21 10:08:51

9700

代码可运行

文章被收录于专栏：springbootspringboot

运行总次数：0

代码可运行

Tomcat源码系列文章

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

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

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

前言

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

一、LifeCycle接口

1、接口介绍

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

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;
    
    /** 第3类：生命周期状态 **/
    // 获取生命周期状态
    public LifecycleState getState();
    // 获取字符串类型的生命周期状态
    public String getStateName();
}

2、生命周期状态

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

public enum LifecycleState {
	// 容器刚刚创建时，即在LifecycleBase实例构造完成时的状态
    NEW(false, null),
    // 容器初始化过程中的状态
    INITIALIZING(false, Lifecycle.BEFORE_INIT_EVENT),
    // 容器初始化完成时的状态
    INITIALIZED(false, Lifecycle.AFTER_INIT_EVENT),
    // 容器启动前的状态
    STARTING_PREP(false, Lifecycle.BEFORE_START_EVENT),
    // 容器启动过程中的状态
    STARTING(true, Lifecycle.START_EVENT),
    // 容器启动完成的状态
    STARTED(true, Lifecycle.AFTER_START_EVENT),
    // 容器停止前的状态
    STOPPING_PREP(true, Lifecycle.BEFORE_STOP_EVENT),
    // 容器停止过程中的状态
    STOPPING(false, Lifecycle.STOP_EVENT),
    // 容器停止完成的状态
    STOPPED(false, Lifecycle.AFTER_STOP_EVENT),
    // 容器销毁过程中的状态
    DESTROYING(false, Lifecycle.BEFORE_DESTROY_EVENT),
    // 容器销毁后的状态
    DESTROYED(false, Lifecycle.AFTER_DESTROY_EVENT),
    // 容器启动、停止过程中出现异常的状态
    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方法：允许子类触发生命周期事件

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 lifecycleListeners.toArray(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等）去实现

@Override
public final synchronized void init() throws LifecycleException {
    // 非NEW状态，不允许调用init()方法
    if (!state.equals(LifecycleState.NEW)) {
    	// 抛出异常
        invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
    }
 
    try {
        // 初始化逻辑之前，先将状态变更为`INITIALIZING（初始化过程中状态）`
        setStateInternal(LifecycleState.INITIALIZING, null, false);
        // 初始化，该方法为一个abstract方法，需要组件自行实现
        initInternal();
        // 初始化完成之后，状态变更为`INITIALIZED（初始化完成状态）`
        setStateInternal(LifecycleState.INITIALIZED, 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类型的

private volatile LifecycleState state = LifecycleState.NEW;。
 
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.STARTING_PREP &&
                        state == LifecycleState.STARTING) ||
                (this.state == LifecycleState.STOPPING_PREP &&
                        state == LifecycleState.STOPPING) ||
                (this.state == LifecycleState.FAILED &&
                        state == LifecycleState.STOPPING))) {
            invalidTransition(state.name());
        }
    }
    // 设置状态
    this.state = state;
    // 触发事件
    String lifecycleEvent = state.getLifecycleEvent();
    if (lifecycleEvent != null) {
        fireLifecycleEvent(lifecycleEvent, data);
    }
}

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

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);
    }
}

3、start

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

public final synchronized void start() throws LifecycleException {
    // `STARTING_PREP启动前`、`STARTING启动中`和`STARTED启动完成时，将忽略start()逻辑
    if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
            LifecycleState.STARTED.equals(state)) {
        return;
    }
 
    // `NEW`状态时，执行init()方法
    if (state.equals(LifecycleState.NEW)) {
        init();
    }
 
    // `FAILED`状态时，执行stop()方法
    else if (state.equals(LifecycleState.FAILED)) {
        stop();
    }
 
    // 不是`INITIALIZED初始化完成`和`STOPPED停止完成`时，则说明是非法的操作
    else if (!state.equals(LifecycleState.INITIALIZED) &&
            !state.equals(LifecycleState.STOPPED)) {
        // 抛出异常
        invalidTransition(Lifecycle.BEFORE_START_EVENT);
    }
 
 	// 一般流程会走到这里，刚走完初始化流程，状态为INITIALIZED（初始化完成状态）
    try {
        // start前的状态设置
        setStateInternal(LifecycleState.STARTING_PREP, null, false);
        // start逻辑，抽象方法，由组件自行实现
        startInternal();
        // start过程中，可能因为某些原因失败，这时需要stop操作
        if (state.equals(LifecycleState.FAILED)) {
            stop();
        } else if (!state.equals(LifecycleState.STARTING)) {
        	// 抛出异常
            invalidTransition(Lifecycle.AFTER_START_EVENT);
        } 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操作留给子类实现

@Override
public final synchronized void stop() throws LifecycleException {
    // `STOPPING_PREP停止前`、`STOPPING停止中`和STOPPED停止完成时，将忽略stop()的执行
    if (LifecycleState.STOPPING_PREP.equals(state) || LifecycleState.STOPPING.equals(state) ||
            LifecycleState.STOPPED.equals(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;
    }

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

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

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

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

        // 如果不是停止中状态也不是异常状态，则抛出异常
        if (!state.equals(LifecycleState.STOPPING) && !state.equals(LifecycleState.FAILED)) {
            invalidTransition(Lifecycle.AFTER_STOP_EVENT);
        }
        // 设置状态为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操作留给子类实现

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

    // `DESTROYING`和`DESTROYED`时，忽略destroy的执行
    if (LifecycleState.DESTROYING.equals(state) ||
            LifecycleState.DESTROYED.equals(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 (!state.equals(LifecycleState.STOPPED) &&
            !state.equals(LifecycleState.FAILED) &&
            !state.equals(LifecycleState.NEW) &&
            !state.equals(LifecycleState.INITIALIZED)) {
        invalidTransition(Lifecycle.BEFORE_DESTROY_EVENT);
    }

    try {
        // destroy前状态设置
        setStateInternal(LifecycleState.DESTROYING, 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是使用模板模式来实现，具体操作留给子类，抽象模板方法如下

// 初始化方法
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.com 删除

生命周期