目录

■前言

■正文开始

线程上下文的核心组成部分

为什么会出现上下文丢失？

直观示例说明

为什么上下文如此重要？

解决上下文丢失的关键

总结

■如果我想在servlet中使用线程，代码应该如何实现

推荐方案：使用 ManagedExecutorService（WebSphere 托管线程池）

备选方案：手动管理线程上下文（如果无法使用 ManagedExecutorService）

关键配置步骤（WebSphere 控制台）

两种方案对比

最佳实践建议

完整示例（生产级代码）

---

■前言

Web应用中，为了提高效率，某段和主业务无关的处理，使用异步处理来处理。

（使用的服务器是WebSphere）

结果报如下错误

webcontexts service getStandard Context Failed to retrieve application name

这个错误的原因是线程上下文丢失造成的，

因此，整理解释一下什么是线程上下文丢失

========================================

■正文开始

线程上下文的核心组成部分

1. 类加载器（ClassLoader）

   • Web 应用有独立的类加载器（隔离其他应用）

   • 负责加载应用中的类、资源和库

   • 丢失后果：ClassNotFoundException、NoClassDefFoundError

2. JNDI（Java Naming and Directory Interface）上下文

   • 提供对应用服务器资源的访问（如数据源、JMS 队列）

   • 丢失后果：NamingException、无法查找 java:comp/env 资源

3. Web 应用上下文（ServletContext）

   • 包含 Web 应用元数据：应用名称、上下文路径、初始化参数

   • 丢失后果：getStandardContext failed to retrieve application name（我遇到的错误）

4. 安全上下文（Security Context）

   • 包含用户认证/授权信息（如 Principal、角色）

   • 丢失后果：NullPointerException 或权限检查失败

5. 事务上下文（Transaction Context）

   • 管理数据库事务边界

   • 丢失后果：事务无法提交/回滚

---

为什么会出现上下文丢失？

1. 线程创建方式

   // 自定义线程不会继承上下文
   new Thread(() -> {
       // 此处丢失所有上下文!
   }).start();

2. Web 容器管理的线程 vs 自定义线程

   特性	Web 容器线程 (如 HTTP 请求线程)	自定义线程
   类加载器	自动设置正确	默认使用系统类加载器
   JNDI 上下文	自动可用	InitialContext() 失败
   ServletContext	通过 getServletContext() 获取	返回 null 或抛出异常
   事务传播	支持	事务边界中断

3. WebSphere 的上下文隔离机制

   • 为每个应用创建独立的沙箱环境

   • 自定义线程被视为"外部线程"，无权访问应用沙箱

---

直观示例说明

假设在 Servlet 中启动线程：

public class MyServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        // 正确环境 (有上下文)
        String appName = getServletContext().getContextPath(); // 成功获取

        new Thread(() -> {
            // 危险区域 (上下文丢失)!
            try {
                // 尝试获取相同信息
                Context ctx = new InitialContext();
                String name = (String) ctx.lookup("java:app/AppName"); // 抛出异常!
            } catch (NamingException e) {
                // 报错: getStandardContext failed to retrieve application name
            }
        }).start();
    }
}

---

为什么上下文如此重要？

当调用以下 API 时会依赖上下文：

// 依赖 Web 上下文
servletContext.getResource("/WEB-INF/config.xml"); 

// 依赖 JNDI 上下文
dataSource = (DataSource) new InitialContext().lookup("jdbc/myDB");

// 依赖类加载器
Class.forName("com.myapp.CustomClass"); 

// 依赖安全上下文
request.isUserInRole("Admin");

---

解决上下文丢失的关键

必须通过以下方式之一传递上下文：

1. 显式传递数据

   // 在 Web 线程中预先获取值
   String appName = getServletContext().getContextPath(); 
   executor.submit(new MyTask(appName)); // 传递值而非依赖上下文

2. 使用托管线程服务（推荐）

   @Resource
   private ManagedExecutorService managedExecutor; // WebSphere 托管
   
   managedExecutor.submit(() -> {
       // WebSphere 自动注入上下文
       Context ctx = new InitialContext(); // 现在正常工作了!
   });

3. 手动恢复上下文（复杂）

   // 在 Web 线程中捕获当前类加载器
   ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
   
   new Thread(() -> {
       // 手动恢复类加载器
       Thread.currentThread().setContextClassLoader(originalClassLoader);
       // 注意：这无法恢复 JNDI 或 ServletContext!
   }).start();

---

总结

线程上下文丢失本质是：当代码脱离 Web 容器管控的线程时，应用服务器无法自动提供运行所需的环境信息。解决的关键在于：

1. 避免在自定义线程中直接访问 Web API

2. 使用服务器托管线程池（ManagedExecutorService）

3. 在 Web 线程中预先获取数据并传递值

这正是您遇到的 getStandardContext failed to retrieve application name 的根本原因——自定义线程中无法关联到 Web 应用的 ServletContext。

===

■如果我想在servlet中使用线程，代码应该如何实现

在 Servlet 中使用自定义线程时，为了正确处理线程上下文问题（特别是在 WebSphere 环境中），强烈推荐使用 Java EE 标准的 ManagedExecutorService。以下是完整的实现方案：

推荐方案：使用 ManagedExecutorService（WebSphere 托管线程池）

import javax.annotation.Resource;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.enterprise.concurrent.ManagedExecutorService;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/asyncTask")
public class ThreadedServlet extends HttpServlet {
    
    // 注入 WebSphere 托管的线程池服务
    @Resource
    private ManagedExecutorService managedExecutor;

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        
        response.setContentType("text/plain");
        PrintWriter out = response.getWriter();
        
        // 提交任务到托管线程池（自动传递线程上下文）
        managedExecutor.submit(() -> {
            try {
                // 在托管线程中安全访问上下文
                String appName = (String) new InitialContext().lookup("java:app/AppName");
                String contextPath = request.getServletContext().getContextPath();
                
                // 执行实际业务逻辑
                processTask(appName, contextPath);
                
                out.println("Task completed successfully in managed thread!");
            } catch (Exception e) {
                out.println("Error in managed thread: " + e.getMessage());
                e.printStackTrace();
            }
        });
        
        out.println("Background task started using ManagedExecutorService...");
    }
    
    private void processTask(String appName, String contextPath) {
        // 这里是实际的业务逻辑
        System.out.println("Processing task for application: " + appName);
        System.out.println("Context path: " + contextPath);
        // 模拟耗时操作
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

备选方案：手动管理线程上下文（如果无法使用 ManagedExecutorService）

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.naming.InitialContext;

@WebServlet("/manualThread")
public class ManualThreadServlet extends HttpServlet {
    
    // 创建普通线程池（不推荐，仅作演示）
    private final ExecutorService executor = Executors.newFixedThreadPool(5);
    
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        
        response.setContentType("text/plain");
        PrintWriter out = response.getWriter();
        
        // 在Web线程中预先获取所需上下文信息
        final String appName = getPredefinedAppName();
        final String contextPath = request.getServletContext().getContextPath();
        final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
        
        // 提交任务到普通线程池
        executor.submit(() -> {
            // 保存原始类加载器（用于恢复）
            ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
            
            try {
                // 手动设置上下文类加载器
                Thread.currentThread().setContextClassLoader(contextClassLoader);
                
                // 使用预先获取的上下文信息
                processTask(appName, contextPath);
                
                out.println("Task completed in manual thread!");
            } catch (Exception e) {
                out.println("Error in manual thread: " + e.getMessage());
                e.printStackTrace();
            } finally {
                // 恢复原始类加载器
                Thread.currentThread().setContextClassLoader(originalClassLoader);
            }
        });
        
        out.println("Background task started using manual thread...");
    }
    
    private String getPredefinedAppName() {
        try {
            // 在Web线程中预先获取应用名称
            return (String) new InitialContext().lookup("java:app/AppName");
        } catch (Exception e) {
            return "default-app";
        }
    }
    
    private void processTask(String appName, String contextPath) {
        // 业务逻辑同上
    }
    
    @Override
    public void destroy() {
        // 关闭线程池
        executor.shutdown();
        super.destroy();
    }
}

关键配置步骤（WebSphere 控制台）

1. 启用并发策略：

   • 登录 WebSphere 管理控制台

   • 导航到：资源 > 并发策略

   • 创建或使用默认的并发策略

2. 绑定到应用（可选，通常自动注入即可工作）：
   在 ibm-application-bnd.xml 中添加：

   <application-bnd>
       <managed-executor-service name="concurrent/executorSvc" />
   </application-bnd>

两种方案对比

特性	ManagedExecutorService	手动线程管理
上下文传播	自动完整传播（类加载器、JNDI、安全等）	仅能手动传递类加载器
资源管理	WebSphere 自动管理生命周期	需手动关闭线程池
事务支持	支持事务上下文传播	不支持事务传播
Servlet API 访问	可直接访问（如 request、response）	只能访问预先获取的数据
WebSphere 兼容性	完全兼容	可能仍有上下文问题
代码复杂度	简单（声明式注入）	复杂（需手动管理上下文）
推荐度	⭐⭐⭐⭐⭐（首选方案）	⭐⭐（备选方案）

最佳实践建议

1. 首选托管线程池：

   @Resource
   private ManagedExecutorService executor; // 始终使用这个

2. 避免在子线程中直接使用 Servlet API：

   // 错误做法（可能引发问题）：
   managedExecutor.submit(() -> {
       request.getSession(); // 可能不安全
   });
   
   // 正确做法（预先获取所需数据）：
   String sessionId = request.getSession().getId();
   managedExecutor.submit(() -> processSession(sessionId));

3. 处理线程中的异常：

   managedExecutor.submit(() -> {
       try {
           // 业务逻辑
       } catch (Exception e) {
           // 1. 记录日志
           // 2. 不要吞掉异常
           // 3. 考虑通知主线程
       }
   });

4. 生命周期管理：

   • 不需要手动关闭 ManagedExecutorService

   • 对于普通线程池，在 Servlet.destroy() 中关闭：

     @Override
     public void destroy() {
         executor.shutdown();
         try {
             if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
                 executor.shutdownNow();
             }
         } catch (InterruptedException e) {
             executor.shutdownNow();
             Thread.currentThread().interrupt();
         }
     }

完整示例（生产级代码）

@WebServlet("/task")
public class ProductionReadyServlet extends HttpServlet {
    
    @Resource
    private ManagedExecutorService managedExecutor;
    
    private static final Logger logger = LoggerFactory.getLogger(ProductionReadyServlet.class);

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws IOException {
        
        // 预先获取所需上下文信息
        String appName = (String) req.getServletContext().getAttribute("app.name");
        String clientIP = req.getRemoteAddr();
        
        // 提交任务
        managedExecutor.submit(new TrackedTask(appName, clientIP));
        
        resp.getWriter().write("Task submitted successfully");
    }
    
    // 封装任务的内部类
    private class TrackedTask implements Runnable {
        private final String appName;
        private final String clientIP;
        
        TrackedTask(String appName, String clientIP) {
            this.appName = appName;
            this.clientIP = clientIP;
        }
        
        @Override
        public void run() {
            MDC.put("app", appName); // 日志上下文
            MDC.put("client", clientIP);
            
            try {
                logger.info("Starting background task");
                // 业务逻辑...
                logger.info("Task completed");
            } catch (Exception e) {
                logger.error("Task failed", e);
            } finally {
                MDC.clear();
            }
        }
    }
}

使用这种模式，您可以：

1. 安全地在后台线程执行任务

2. 保留必要的上下文信息

3. 获得完善的错误处理和日志跟踪

4. 完全兼容 WebSphere 环境

5. 避免 getStandardContext failed 错误

对于大多数场景，使用 ManagedExecutorService 并遵循上述模式即可解决线程上下文问题。

==