Réglage de Tomcat de la mémoire et de la consommation cpu

Vous pouvez limiter la accepté opérationnels et les numéros de connexion dans le conf/server.xml de configuration.

Ont

<Executor name="tomcatThreadPool" namePrefix="catalina-exec-" 
    maxThreads="16" minSpareThreads="1"/>

et

<Connector executor="tomcatThreadPool"
           port="8080" protocol="HTTP/1.1" 
           connectionTimeout="20000" 
           redirectPort="8443" 
           />

ou

<Connector port="8080" protocol="HTTP/1.1" 
           connectionTimeout="20000" 
           redirectPort="8443" 
           maxThreads='16'/>

dans le fichier de config et cela devrait frein à vous.

Edit: Basé sur votre commentaire vous pouvez déplacer la transformation dans le thread dédié piscine de taille en fonction de votre CPU count (Runtime.getRuntime().availableProcessors()) (voir ExecutorService et Les exécuteurs.) Ensuite, vous pouvez appliquer un délimitée LinkedBlockingQueue de limiter le nombre de tâches en attente (n'oubliez pas de spécifier un RejectedExecutionHandler de faire le blocage et l'ajouter à la file d'attente est pleine).

Edit 2: Ajouté des liens vers les classes. Vous y trouverez quelques échantillons.

Edit 3: Un exemple de la méthode que j'ai utilisé dans un projet.

/**
 * Creates a new thread pool based on some attributes
 * @param poolSize the number of worker threads in the thread pool
 * @param poolName the name of the thread pool (for debugging purposes)
 * @param priority the base priority of the worker threads
 * @param capacity the size of the task queue used
 * @return the ExecutorService object
 */
private ExecutorService newPool(int poolSize, 
String poolName, final int priority, int capacity) {
    int cpu = Runtime.getRuntime().availableProcessors();
    ExecutorService result = null;
    if (poolSize != 0) {
        if (poolSize == -1) {
            poolSize = cpu;
        }
        if (capacity <= 0) {
            capacity = Integer.MAX_VALUE;
        }
        result = new ThreadPoolExecutor(poolSize, poolSize, 
                120, TimeUnit.MINUTES, 
                new LinkedBlockingQueue<Runnable>(capacity), 
        new ThreadFactory() {
            @Override
            public Thread newThread(Runnable runnable) {
                Thread t = new Thread(runnable);
                t.setPriority(priority);
                return t;
            }
        }, new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r,
                    ThreadPoolExecutor executor) {
                if (!executor.isShutdown()) {
                    try {
                        executor.getQueue().put(r);
                    } catch (InterruptedException ex) {
                        //give up
                    }
                }
            }
        });
    }
    return result;
}

Et vous pouvez l'utiliser de cette façon:

ExecutorService exec = newPool(-1, "converter pool", Thread.NORM_PRIORITY, 500);
servletContext.setAttribute("converter pool", exec);

Et dans votre servlet

ExecutorService exec = (ExecutorService)servletContext
.getAttribute("converter pool");

exec.submit(new Runnable() {
    public void run() {
        //your code for transformation goes here
    }
}