Profiling Kotlin Code: Finding Bottlenecks in Practice

Profiling Kotlin Code: Finding Bottlenecks in Practice

When your Kotlin server starts to slow down and users complain about delays, the first thing that comes to mind is "the problem must be in the database." But often the bottleneck is the code itself: slow algorithms, endless collections, or inefficient memory management. In this article, we will explore practical tools and techniques for profiling Kotlin code that will help you quickly find and eliminate bottlenecks.

Why is profiling important for a Kotlin developer?

Kotlin runs on top of the JVM, and although it saves us from many Java problems (such as NullPointerException), performance remains a target. Even simple constructs like map, filter, or forEach can create unexpected overhead if used incorrectly. Profiling allows you to look inside the application and understand which functions consume the most CPU or memory.

In this article, we will cover three main approaches:

• The built-in IntelliJ IDEA profiler (for local development)
• Command-line utilities jstack and jmap (for production)
• The Hiccup library (for programmatic profiling)

1. The built-in IntelliJ IDEA profiler — your first assistant

If you are using IntelliJ IDEA Ultimate, you already have a powerful profiling tool. It works directly in the IDE and does not require installing additional libraries.

How to run it:

1. Start your application in Debug mode.
2. Go to the Profiler tab (usually at the bottom right).
3. Click CPU Profiling or Memory Profiling.
4. Stop profiling after a few seconds and analyze the Flame Graph.

Example code for testing:

fun main() {    val numbers = (1..1_000_000).toList()

    // Bottleneck: repeatedly creating lists    val result = numbers        .filter { it % 2 == 0 }        .map { it * 2 }        .take(100)        println(result)}

Running the profiler, you will see that a significant portion of time is spent on .filter() and .map(). The solution is to use Sequences (lazy sequences):

fun main() {    val numbers = (1..1_000_000).toList()

    // Optimized version    val result = numbers.asSequence()        .filter { it % 2 == 0 }        .map { it * 2 }        .take(100)        .toList()        println(result)}

The profiler will show that execution time has decreased by 2-3 times.

2. Command-line utilities: jstack and jmap for production

When the application is already running on a server, you cannot simply connect the IDE profiler. This is where JDK utilities come to the rescue.

jstack — Thread analysis (Thread Dump)

Used when the application "freezes" or consumes 100% CPU. jstack shows which threads are currently executing.

Usage example:

# Find the PID of your Kotlin processps aux | grep kotlin

# Take a thread snapshotjstack -l 12345 > thread_dump.txt

# Analyze: look for locks and infinite loops

What to look for in the output:

• Threads in RUNNABLE state — they are actively using CPU.
• Threads in BLOCKED state — they are waiting for a resource to be released (often due to synchronization).
• Repeated method calls — a sign of an infinite loop.

jmap — Memory analysis (Heap Dump)

If you have a memory leak