Tomcat Request Cookie 丢失问题解决_Linux

一、问题描述

生产环境偶尔(涉及到多线程处理)出现"前端传递`cookie为空"的告警，导致前端请求丢失，出现请求失败问题。告警内容如下

前端传递cookie为空
告警内容：服务端获取request cookie为空，请尽快处理！！！
appid：xxxxxx
ip：xx.xx.xxx.xx
告警事件：2024-03-15

背景：为什么要加cookie告警：项目出海，需要保证多语言，语言信息从cookie中获取，所以添加了cookie告警，告警后发到工作群中，但是相关开发人员告知自己能够正常访问，没有问题，因为正好周五，自己觉得偶发性肯定和并发相关，所以周末研究了下代码，发现和tomcat rquest复用机制和threadlocal的使用存在缺陷，导致这个偶发性问题

在分析原因前，先需要搞懂一个概念：request在tomcat里面是循环使用的

二、tomcat 中 reqeust 复用机制

request对象的复用机制是为了提高性能和减少垃圾收集压力而设计的。tomcat使用了一种对象池的机制来管理request对象和response对象。通过复用这些对象，tomcat可以避免频繁地创建和销毁对象，从而提高系统的效率。

复用机制的工作原理【1】对象池：tomcat维护一个对象池，用于存储request对象和response对象。当一个新的http请求到达时，tomcat从对象池中获取一个空闲的request对象和response对象。如果对象池中没有空闲的对象，tomcat会创建新的对象。简单看个案例：

public class requestpool {
    private stack<request> pool = new stack<>();
    // 获取对象：getrequest 方法从对象池中获取一个 request 对象。如果对象池为空，则创建一个新的 request 对象。
    public request getrequest() {
        if (pool.isempty()) {
            return new request();
        } else {
            return pool.pop();
        }
    }
    // 释放对象：releaserequest 方法将 request 对象重置（调用 recycle 方法）并放回对象池中。
    public void releaserequest(request request) {
        request.recycle();
        pool.push(request);
    }
}

【2】对象重置：当一个请求处理完毕后，request对象会被重置（通过调用recycle方法），以清除上一次请求的状态，使其可以安全地用于下一个请求。以下是org.apache.catalina.connector.request类中recycle方法的简化源码和解释：

public class request {
    // various fields representing the state of the request
    private string protocol;
    private string method;
    private string requesturi;
    private string querystring;
    private string remoteaddr;
    private string remotehost;
    private string servername;
    private int serverport;
    private boolean secure;
    private inputstream inputstream;
    private reader reader;
    private servletinputstream servletinputstream;
    private bufferedreader bufferedreader;
    private map<string, object> attributes;
    private map<string, string[]> parameters;
    private cookie[] cookies;
    private httpsession session;

    // other fields and methods...

    /**
     * recycle this request object.
     */
    public void recycle() {
        // reset the state of the request object
        // 重置基本属性：recycle 方法将 request 对象的基本属性（如 protocol、method、requesturi 等）重置为初始状态（通常为 null 或默认值）。
        // 清空集合和数组：attributes 和 parameters 集合被清空，以确保没有残留的请求数据。cookies 数组也被重置为 null。
        // 重置流和读者：inputstream、reader、servletinputstream 和 bufferedreader 被重置为 null，以确保没有残留的输入流和读者对象。
        // 重置会话：session 被重置为 null，以确保没有残留的会话信息。
        protocol = null;
        method = null;
        requesturi = null;
        querystring = null;
        remoteaddr = null;
        remotehost = null;
        servername = null;
        serverport = 0;
        secure = false;
        inputstream = null;
        reader = null;
        servletinputstream = null;
        bufferedreader = null;
        attributes.clear();
        parameters.clear();
        cookies = null;
        session = null;

        // other reset logic...
    }
}

recycle执行的时机： recycle方法在tomcat源码中的调用时机主要是在请求处理完毕之后，request对象被返回到对象池之前。具体来说，recycle方法通常在以下几个场景中被调用：
【1】请求处理完毕后：在tomcat的org.apache.coyote.request类中，recycle方法通常在请求处理完毕后被调用。例如，在abstractprocessorlight类中处理请求和响应的逻辑中，recycle方法被调用来重置request对象。

// org.apache.coyote.abstractprocessorlight
public class abstractprocessorlight<s> implements processor {
    // various fields and methods...

    @override
    public socketstate process(socketwrapperbase<s> socketwrapper, socketevent status) throws ioexception {
        // process the request and response
        try {
            // request processing logic...
        } finally {
            // recycle the request and response objects
            request.recycle();
            response.recycle();
        }
        return socketstate.closed;
    }
}

【2】连接关闭时：在tomcat的org.apache.coyote.http11.http11processor类中，当连接关闭时，recycle方法也会被调用。例如，当处理完一个请求并决定关闭连接时，会调用recycle方法。

// org.apache.coyote.http11.http11processor
public class http11processor extends abstractprocessorlight<socketchannel> {
    // various fields and methods...

    @override
    public socketstate service(socketwrapperbase<socketchannel> socketwrapper) throws ioexception {
        // service the request and response
        try {
            // request servicing logic...
        } finally {
            // recycle the request and response objects
            request.recycle();
            response.recycle();
        }
        return socketstate.closed;
    }
}

【3】异常处理：在处理请求的过程中，如果发生异常，tomcat也会确保调用recycle方法来重置request对象。例如：

// org.apache.coyote.http11.http11processor
public class http11processor extends abstractprocessorlight<socketchannel> {
    // various fields and methods...

    @override
    public socketstate service(socketwrapperbase<socketchannel> socketwrapper) throws ioexception {
        try {
            // request servicing logic...
        } catch (exception e) {
            // handle exception and recycle request
            request.recycle();
            response.recycle();
            throw e;
        }
    }
}

后期原因分析中需要使用到requestfacade，这里解释下requestfacade与request之间的关系：requestfacade是一个包装类facade，用于保护底层的request对象，确保应用程序无法直接访问和修改内部实现细节。

【1】request类： request类是tomcat内部用来表示http请求的类，包含了请求的所有详细信息。该类提供了许多方法来访问和操作请求的各个部分，例如请求头、请求参数、输入流等。

【2】requestfacade 类： requestfacade类是一个包装器，用于保护request对象。它实现了javax.servlet.http.httpservletrequest接口，并将方法调用委托给内部的request对象。通过使用requestfacade，tomcat确保了应用程序只能通过标准的httpservletrequest接口访问请求数据，而不能直接访问或修改request对象的内部实现。

具体实现：在tomcat中，requestfacade类通常包含一个request对象的引用，并将所有的接口方法调用委托给这个内部的request对象。例如：

// org.apache.catalina.connector.requestfacade
public class requestfacade implements httpservletrequest {
    private final request request;

    public requestfacade(request request) {
        this.request = request;
    }

    @override
    public string getparameter(string name) {
        return request.getparameter(name);
    }

    // other methods from httpservletrequest interface
    // all methods delegate to the internal request object
}

使用场景：在tomcat处理请求的过程中，当需要将httpservletrequest对象传递给应用程序时，tomcat会创建一个requestfacade实例，并将内部的request对象传递给它。例如

// org.apache.catalina.connector.coyoteadapter
public class coyoteadapter implements adapter {
    @override
    public void service(org.apache.coyote.request req, org.apache.coyote.response res) throws exception {
        request request = (request) req.getnote(adapter_notes);
        response response = (response) res.getnote(adapter_notes);

        // create a requestfacade to pass to the application
        httpservletrequest requestfacade = request.getrequest();

        // pass the requestfacade to the application
        context.getpipeline().getfirst().invoke(requestfacade, response);
    }
}

三、原因分析

【1】第一次请求由线程a正常执行，执行完成后执行recycle方法，将requestfacade中的属性修改为null，准备下次复用，但是当前线程的threadlocal没有被清理。

【2】第二次请求恰好也由线程a执行（这也是偶发的原因），通过threadlocal获取requestfacade对象，并通过getcookies获取cookie，因为第一次请求结束后将cookie置为null并将cookiesparsed修改为了false，但是这次请求再次调用getcookies的时候，将cookiesparsed修改为了true。用来表示requestfacade a的cookies已经被解析过了。同时需要注意，此时第一次请求的生命周期已经结束了，所以重置cookiesparsed的操作就不复存在了，tomcat重新复用requestfacade a的时候cookies就会获取到一个null。

@override
public cookie[] getcookies() {
    if (!cookiesparsed) {
        parsecookies();
    }
    return cookies;
}

protected void parsecookies() {
    cookiesparsed = true;

    cookies servercookies = coyoterequest.getcookies();
    int count = servercookies.getcookiecount();
    if (count <= 0) {
        returnl
    }

    cookies = new cookie[count];
}

【3】第三次请求时，tomcat复用了requestfacade a，当正常解析cookies的时候发现cookiesparsed为true就跳过了正确解析的环节，当需要使用cookie的时候发现为空，本次请求直接被中止。（灵异事件）

解决方案：

【1】threadlocal使用完后一定需要clean；
【2】不要在跨线程中使用request对象。可以使用-dorg.apache.catalina.connector.recycle_facades=true禁止复用。在项目的extraenv.sh中设置参数后，如果有访问已经被回收的request对象，就会抛出the request object has been recycled and is no longer associated with this facade异常，以此就能定位到问题