在 Tomcat 中运行后台 Java 程序

Question

有人可以在这里提供建议吗？我遇到过这样的情况：用户将通过 Java JSP 和 servlet 以交互方式向我的应用程序提交数据挖掘请求，该应用程序将动态地制定数据等的关联规则。

由于这样的工作可能需要一段时间，我正在考虑服务器上的某种进程在后台运行这样的请求，这样它就不会“锁定”会话，并且可能会使用大量的服务器内存，从而造成损害系统的。

由于该系统由一系列 Java JSP 和 servlet 组成，这些 Java JSP 和 servlet 在 MySQL 数据库上的 Tomcat 容器中运行，有人可以建议前进的方向吗？

谢谢

摩根先生

Answer 1

使用 ExecutorService。

不过，您应该做一些事情，将线程标记为守护线程，这样它至少不会在错误情况下占用 tomcat，并且当您的 servlet 上下文被破坏时（例如，当您重新部署或停止您的应用程序时），您应该停止执行程序为此，请使用 ServletContextListener：

public class ExecutorContextListener implements ServletContextListener {
    private  ExecutorService executor;

    public void contextInitialized(ServletContextEvent arg0) {
        ServletContext context = arg0.getServletContext();
        int nr_executors = 1;
        ThreadFactory daemonFactory = new DaemonThreadFactory();
        try {
            nr_executors = Integer.parseInt(context.getInitParameter("nr-executors"));
        } catch (NumberFormatException ignore ) {}

        if(nr_executors <= 1) {
        executor = Executors.newSingleThreadExecutor(daemonFactory);
        } else {
        executor = Executors.newFixedThreadPool(nr_executors,daemonFactory);
       }
          context.setAttribute("MY_EXECUTOR", executor);
      }

    public void contextDestroyed(ServletContextEvent arg0) {
        ServletContext context = arg0.getServletContext();
        executor.shutdownNow(); // or process/wait until all pending jobs are done
    }

}
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

/**
 * Hands out threads from the wrapped threadfactory with setDeamon(true), so the
 * threads won't keep the JVM alive when it should otherwise exit.
 */
public class DaemonThreadFactory implements ThreadFactory {

    private final ThreadFactory factory;

    /**
     * Construct a ThreadFactory with setDeamon(true) using
     * Executors.defaultThreadFactory()
     */
    public DaemonThreadFactory() {
        this(Executors.defaultThreadFactory());
    }

    /**
     * Construct a ThreadFactory with setDeamon(true) wrapping the given factory
     * 
     * @param thread
     *            factory to wrap
     */
    public DaemonThreadFactory(ThreadFactory factory) {
        if (factory == null)
            throw new NullPointerException("factory cannot be null");
        this.factory = factory;
    }

    public Thread newThread(Runnable r) {
        final Thread t = factory.newThread(r);
        t.setDaemon(true);
        return t;
    }
}

您必须将上下文侦听器添加到 web.xml，您还可以在其中指定要运行后台作业的线程数：

  <listener>
    <listener-class>com.example.ExecutorContextListener</listener-class>
  </listener>

您可以从您的 web.xml 访问执行程序 。 servlet 并向其提交作业：

ExecutorService executor = (ExecutorService )getServletContext().getAttribute("MY_EXECUTOR");
...
executor.submit(myJob);

如果您使用 Spring，所有这些甚至都可以更简单

Answer 2

我认为 Quartz 调度程序应该能够完成你在这里想做的事情。以下是一些 Quartz 的示例。使用它，您可以启动一个 cron 来快速轮询以处理传入的请求。我实际上是为我的一个项目这样做的。

Answer 3

一个轻量级的解决方案（与使用诸如quartz之类的调度程序相反）是将处理放入后台线程并通过ExecutorService运行。

http://download.oracle.com/javase /6/docs/api/java/util/concurrent/Executors.html
http://download.oracle.com/javase /6/docs/api/java/util/concurrent/ExecutorService.html

Answer 4

也许 JMS 才是您真正需要的，但是在 Tomcat 上使用它需要额外的努力，因为它只是 Servlet 容器。您可以切换到真正的 AppServer，如 Glassfish 或 JBoss，或者自行将 JMS 功能添加到 Tomcat（下面的链接）