1. Overview

Optimizing your code performance is critical for the success of your profile. Did you know that Akamai's research found that 57% of online consumers abandon a website if a page takes longer than 3 seconds to load? In this post, you will learn how to optimize your Java code and improve your code performance.

2. Virtual Threads

Say no more to OutOfMemoryError: unable to create new native thread Error.

Java virtual threads, introduced in Java 19, can significantly improve the performance of your project.

In the previous releases of Java, there was only 1 type of thread (Classic threads) when a classic thread is created an OS thread is allocated and the number of threads is limited to the OS threads.

Starting from JDK 19, you can create virtual threads which are much lighter than OS threads and you can create and run thousands of virtual threads in an application.

To enable virtual threads in a Spring Boot application add the following code to your application.properties.

spring.threads.virtual.enabled=true

3. Lazy loading

A lot of performance problems arise from fetching data that you don't need.

It's best practice to only load objects when needed.

For instance, you can use FetchLazy in Hibernate but always keep in mind that the appropriate fetch strategy depends on the specific use case you're dealing with.

fetch = FetchType.LAZY

4. Cache

Minimize disk access by caching frequently accessed data. By using proper caching techniques you can reduce latency, avoid network congestion and improve content availability.

The Spring framework provides support for various cache providers including but not limited to Redis, Caffeie, Cache2k etc...

5. Avoid GenerationType.TABLE

When choosing a key generation strategy in JPA, it's important to select the one that best fits the database you're using.

GenerationType.TABLE

Avoid using GenerationType.TABLE for its performance overhead. Each time a primary key is needed a LOCK statement is executed, along with a select and update on the sequence table.

GenerationType.IDENTITY

GenerationType.IDENTITY is best suited for MySQL because MySQL uses auto-increment fields and GenerationType.IDENTITY works well with this.

GenerationType.SEQUENCE

GenerationType.SEQUENCE is typically used with PostgreSQL and Oracle. Both databases support sequences, which are database objects that generate a sequence of unique numbers.

6. Query Plan Cache

Hibernate's Query Plan Cache is a key feature that can improve the performance of your application.

When hibernate executes a JPQL query, the corresponding SQL query needs to be generated. This process involves parsing the query to an Abstract Syntax Tree, translating the tree to an SQL query and finally mapping the result back to Java objects.

Once this process is complete, hibernate caches the process so that it doesn't need to perform these steps again for the same query.

To enable and configure the Query Plan cache use the following code:

hibernate.query.plan_cache_max_size=2048 # Maximum number of query plans in the cache

hibernate.query.plan_parameter_metadata_max_size=128 # Max size of query plans with parameter metadata

7. Conclusion

Optimizing Java code performance is essential for delivering fast and responsive applications.

By leveraging modern features like virtual threads, implementing lazy loading, using efficient caching strategies, and optimizing your database operations, you can significantly improve your application's performance.

Posted on 10-03-2024

Links