3 Ways to tune Apache Tomcat in Spring Boot

Tuning Apache Tomcat in Spring Boot involves optimizing its configuration and settings to achieve better performance and resource…

Tuning Apache Tomcat in Spring Boot involves optimizing its configuration and settings to achieve better performance and resource utilization for your specific application. Tomcat is a widely used Java Servlet container for hosting Java-based web applications. Below are the ways we can tune Apache Tomcat.

1. Thread Pools (Connectors and Executors) Setting

2. Using NIO or APR Connectors

3. JVM Optimization

Thread Pools Settings

Tuning Apache Tomcat threads in a Spring Boot application involves configuring the embedded Tomcat server to optimize its thread handling for your specific application. Spring Boot makes it relatively straightforward to tune Tomcat’s thread settings. 
Here’s how you can do it:

Configure in application.properties orapplication.yml:
To configure Tomcat thread settings, you can use the server.tomcat properties in your application.properties or application.yml file. The primary properties you'll want to adjust for thread balancing are:

• server.tomcat.max-threads: Sets the maximum number of threads in the Tomcat thread pool.

• server.tomcat.min-spare-threads: Specifies the minimum number of idle threads to keep in the pool.

• server.tomcat.accept-count: Sets the maximum queue length for incoming connection requests.

Example:

server.tomcat.max-threads=200
server.tomcat.min-spare-threads=10
server.tomcat.accept-count=100

server:
  tomcat:
    max-threads: 200
    min-spare-threads: 10
    accept-count: 100

Use Executors (Optional)
While Spring Boot provides properties to configure the thread pool, you can achieve more advanced thread management by using an executor. You can create and configure an executor bean in your Spring Boot application and configure it as a bean in your application configuration. This allows you more flexibility in managing the thread pool:

Example:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class ExecutorConfig {
    @Bean
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(200);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("custom-executor-");
        return executor;
    }
}

In the above examples, we’ve set the maximum queue capacity to 100. You can adjust this value according to your application’s requirements. The appropriate value depends on the expected traffic and the ability of your server to handle queued requests efficiently.

Keep in mind that when the maximum queue capacity is reached, additional incoming requests will be rejected, which may lead to client connections being refused. Therefore, it’s important to set this value based on your application’s capacity and the resources available on your server.

You can then configure your Tomcat connector to use this custom executor by setting the executor property in your application.properties:

Example:

server.tomcat.executor=customExecutor

Using NIO or APR Connectors

Using NIO (New I/O) or APR (Apache Portable Runtime) connectors in Spring Boot with Apache Tomcat can significantly optimize your web application’s performance, especially when dealing with a high number of concurrent connections and non-blocking I/O operations. These connectors offer improved scalability and responsiveness. Here’s how they can optimize Tomcat in a Spring Boot application:

NIO Connector
The NIO connector uses Java’s New I/O framework and non-blocking I/O operations. It can be particularly beneficial for applications that require high concurrency and efficient handling of many simultaneous connections. Here’s how to use the NIO connector in Spring Boot:

Example:

server.tomcat.protocol="org.apache.coyote.http11.Http11NioProtocol"

Advantages of the NIO connector

• Reduced thread count: NIO allows Tomcat to handle more connections with fewer threads, reducing thread management overhead.

• Better scalability: NIO is well-suited for applications with many concurrent connections, such as WebSocket and Comet applications.

APR Connector
The APR connector uses the Apache Portable Runtime library to provide native performance enhancements and is recommended for production deployments. It can improve performance, especially for high-traffic, production-grade applications. Here’s how to use the APR connector in Spring Boot:

server.tomcat.protocol="org.apache.coyote.http11.Http11AprProtocol"

To enable the APR connector, you need to install the APR libraries on your server and ensure that your Tomcat installation is built with APR support.

Advantages of the APR connector

• Improved performance: The APR connector leverages native code for better performance and efficiency.

• Support for advanced features: APR supports features like SSL, improved request processing, and better connection handling.

JVM Optimization

Optimizing the Java Virtual Machine (JVM) for Apache Tomcat is crucial to ensure that your Tomcat-based applications run efficiently and perform well. Here are some key considerations for JVM optimization when using Tomcat:

Choose the Right JVM Version: Make sure you are using an appropriate and up-to-date JVM version. Oracle’s JDK (now known as Oracle GraalVM), OpenJDK, and AdoptOpenJDK are commonly used with Tomcat. Choose a version that is supported, secure, and compatible with your application.

Select the Appropriate Garbage Collector: The garbage collector (GC) is responsible for managing memory in the JVM. Selecting the right GC algorithm can have a significant impact on your application’s performance. Common choices include:

• Parallel Garbage Collector (GC): Suitable for most applications, especially those with a lot of short-lived objects.

• Concurrent Mark-Sweep (CMS) GC: Offers lower pause times but may have higher overhead.

• G1 Garbage Collector: Designed for applications requiring low-latency and predictable pause times.

• Z Garbage Collector: A low-latency collector available in more recent JVM versions.

Choose the GC algorithm based on your application’s characteristics and performance requirements. You can set the GC in your Tomcat’s catalina.sh or setenv.sh script using the JAVA_OPTS environment variable.

Tune Heap Size: Proper heap size settings are essential for optimal JVM performance. Tomcat applications often require careful heap size configuration. Common heap size options include:

• -Xmx (maximum heap size): Set it to an appropriate value based on your application's memory requirements.

• -Xms (initial heap size): Configure it for an initial heap size that balances startup performance and memory efficiency.

• -Xmn (young generation size): Adjust the size of the young generation, considering the application's object creation patterns.

Enable Just-In-Time (JIT) Compilation: JIT compilation can significantly improve application performance. Modern JVMs come with advanced JIT compilers. Ensure that your JVM is configured to utilize JIT compilation effectively.

JVM Options: Configure other JVM options that can affect performance and memory management. Some commonly used options include:

• -XX:MaxMetaspaceSize: Adjust the maximum metaspace size, especially if you're using Java 8 or earlier.

• -XX:MaxDirectMemorySize: Configure the maximum direct memory size if your application relies heavily on direct memory.

1. Conduct load testing to simulate real-world traffic and ensure that your thread configuration can handle the expected load without performance degradation.

Conclusion: 
Balancing Tomcat threads in a Spring Boot application is critical to achieving optimal performance. The specific settings may vary based on your application’s requirements, so continuous monitoring and adjustments are essential.