Profilage du code Kotlin : trouver les goulots d'étranglement pour les débutants

Introduction : pourquoi le profilage du code Kotlin est important pour les débutants

Les applications modernes en Kotlin fonctionnent rapidement, mais sans contrôle des performances, même un petit projet peut se transformer en application lente. Le profilage est le processus de mesure du temps d'exécution, de l'utilisation de la mémoire et d'autres ressources, afin de trouver les goulots d'étranglement (bottlenecks). Pour les développeurs débutants, savoir profiler le code est une compétence clé qui aide à écrire des programmes efficaces.

Dans cet article, nous allons voir comment trouver les parties lentes dans le code Kotlin à l'aide d'outils intégrés et de bibliothèques populaires. Vous apprendrez à mesurer le temps d'exécution d'une fonction, à analyser l'utilisation de la mémoire et à optimiser les parties critiques.

Outils de profilage Kotlin de base

Pour profiler le code Kotlin, plusieurs approches sont disponibles, allant de simples mesures de temps à des profileurs professionnels. Examinons trois méthodes principales adaptées aux débutants.

1. La fonction intégrée measureTimeMillis

La façon la plus simple de mesurer le temps d'exécution est d'utiliser la fonction standard measureTimeMillis de la bibliothèque standard Kotlin. Elle renvoie le temps en millisecondes passé à exécuter un bloc de code.

import kotlin.system.measureTimeMillis\n\nfun main() {\n    val time = measureTimeMillis {\n        // Simulation d'un travail lourd\n        var sum = 0L\n        for (i in 1..1_000_000) {\n            sum += i\n        }\n        println("Somme : $sum")\n    }\n    println("Temps d'exécution : $time ms")\n}

Cette méthode est idéale pour des tests rapides, mais elle ne montre pas quelle partie du code à l'intérieur du bloc consomme le plus de ressources. Pour une analyse plus détaillée, utilisez des profileurs.

2. Utilisation de System.nanoTime()

Pour des mesures plus précises (nanosecondes), vous pouvez utiliser System.nanoTime(). Cela est utile lorsque vous devez mesurer des micro-optimisations.

fun main() {\n    val start = System.nanoTime()\n    // Votre code\n    Thread.sleep(100) // Simulation d'un délai\n    val end = System.nanoTime()\n    println("Temps : ${(end - start) / 1_000_000} ms")\n}

Notez que nanoTime() n'est pas lié à l'heure système, il convient donc uniquement pour mesurer des intervalles, et non le temps absolu.

3. Profileurs professionnels : JProfiler et VisualVM

Pour un travail sérieux sur les performances, utilisez des outils qui fonctionnent au niveau de la JVM (Kotlin est compilé en bytecode JVM). Deux options gratuites populaires :

\n
• JProfiler — un outil commercial puissant avec une version d'essai. Permet de profiler le CPU, la mémoire, les threads et les bases de données.
\n
• VisualVM — un outil gratuit inclus dans le JDK. Convient aux débutants : affiche l'utilisation de la mémoire, le nombre d'objets et le temps d'exécution des méthodes.
\n

Pour lancer VisualVM, il suffit de le télécharger depuis le site officiel et de le connecter à votre processus Kotlin. Vous verrez le temps d'exécution réel de chaque méthode en temps réel.

Exemple pratique : trouver un goulot d'étranglement dans un algorithme

Imaginez que vous avez écrit une fonction pour trouver les doublons dans une liste. Elle fonctionne, mais ralentit sur de grandes données. Trouvons le goulot d'étranglement à l'aide du profilage.

Étape 1. Écrivons un code lent

fun findDuplicates(list: List<Int>): List<Int> {\n    val duplicates = mutableListOf<Int>()\n    for (i in list.indices) {\n        for (j in i + 1 until list.size) {\n            if (list[i] == list[j] && !duplicates.contains(list[i])) {\n                duplicates.add(list[i])\n            }\n        }\n    }\n    return duplicates\n}\n\nfun main() {\n    val data = (1..10_000).toList() + (1..100).toList() // 100 doublons\n    val time = measureTimeMillis {\n        val result = findDupli