Chronicle Map pour Java : guide complet avec exemples

Chronicle Map est une implémentation ConcurrentMap haute performance et off-heap (hors tas) pour Java, développée par Chronicle Software. Contrairement aux HashMap ou ConcurrentHashMap classiques qui stockent les données dans le tas JVM (heap), Chronicle Map place les données directement dans la mémoire vive en dehors du tas géré. Cela permet d'éviter les surcoûts liés au garbage collector (GC) et d'offrir une latence prévisible, même avec de très gros volumes de données (gigaoctets et téraoctets).

Cette bibliothèque est idéale pour les scénarios nécessitant une faible latence, un débit élevé et une gestion des données sans impact sur les pauses du GC. Ses applications typiques incluent : les systèmes financiers (plateformes de trading), la mise en cache, les systèmes temps réel, le stockage de sessions, et toute application où la performance déterministe est cruciale. Chronicle Map prend en charge l'accès multithread, la sérialisation des clés et des valeurs, et peut être configurée pour la persistance (sauvegarde des données sur disque).

Dans cet article, nous allons explorer en détail l'installation, les méthodes principales, fournir de nombreux exemples concrets et partager des conseils d'optimisation. À la fin, vous serez en mesure d'utiliser Chronicle Map en toute confiance dans vos projets Java.

1. Installation

Chronicle Map est distribué via Maven Central. Pour l'utiliser dans votre projet, ajoutez la dépendance suivante à votre fichier pom.xml (Maven) :

<dependency>
    <groupId>net.openhft</groupId>
    <artifactId>chronicle-map</artifactId>
    <version>3.25ea0</version> <!-- Vérifiez la version actuelle sur Maven Central -->
</dependency>

Si vous utilisez Gradle, ajoutez cette ligne dans votre build.gradle :

implementation 'net.openhft:chronicle-map:3.25ea0'

2. Démarrage rapide — exemple minimal fonctionnel

Créons une carte simple qui stocke des paires "nom d'utilisateur" (String) et "nombre de connexions" (Integer) :

import net.openhft.chronicle.map.ChronicleMap;

public class ExempleRapide {
    public static void main(String[] args) {
        try (ChronicleMap<String, Integer> carte = ChronicleMap
                .of(String.class, Integer.class)
                .name("carte-utilisateurs")
                .averageKey("utilisateur_moyen")
                .averageValue(100)
                .entries(10_000)
                .create()) {

            carte.put("alice", 42);
            carte.put("bob", 87);
            System.out.println("Connexions d'alice : " + carte.get("alice"));
            System.out.println("Taille de la carte : " + carte.size());
        }
    }
}

3. Méthodes principales de Chronicle Map

Chronicle Map implémente l'interface ConcurrentMap et propose des méthodes supplémentaires pour un contrôle fin. Voici les plus importantes :

4. Exemple avancé : persistance et configuration

Chronicle Map peut être configurée pour sauvegarder automatiquement les données sur disque. Voici un exemple avec persistance :

import net.openhft.chronicle.map.ChronicleMap;
import java.io.File;

public class ExemplePersistance {
    public static void main(String[] args) {
        File fichierDonnees = new File("donnees-utilisateurs.dat");

        try (ChronicleMap<String, Integer> carte = ChronicleMap
                .of(String.class, Integer.class)
                .name("carte-persistante")
                .averageKey("utilisateur_moyen")
                .averageValue(50)
                .entries(100_000)
                .createPersistedTo(fichierDonnees)) {

            carte.put("charlie", 15);
            carte.put("diana", 230);
            System.out.println("Données sauvegardées dans : " + fichierDonnees.getAbsolutePath());
        }

        // Réouverture de la carte persistée
        try (ChronicleMap<String, Integer> carteChargee = ChronicleMap
                .of(String.class, Integer.class)
                .name("carte-persistante")
                .averageKey("utilisateur_moyen")
                .averageValue(50)
                .entries(100_000)
                .createOrRecoverPersistedTo(fichierDonnees, false)) {

            System.out.println("Valeur de charlie : " + carteChargee.get("charlie"));
            System.out.println("Valeur de diana : " + carteChargee.get("diana"));
        }
    }
}

5. Conseils de performance

• Préallouez correctement : Utilisez entries() pour définir le nombre maximal d'entrées attendu. Chronicle Map n'effectue pas de redimensionnement dynamique.
• Optimisez la sérialisation : Pour les objets complexes, implémentez BytesMarshallable pour des performances de sérialisation optimales.
• Évitez size() fréquent : Cette méthode parcourt la carte et peut être coûteuse. Utilisez-la avec parcimonie.
• Utilisez des clés et valeurs de taille constante : Si possible, privilégiez des types de données de taille fixe (ex. long au lieu de String).
• Testez avec vos données réelles : Les performances dépendent fortement de la distribution de vos données. Effectuez toujours des benchmarks dans votre contexte.

6. Conclusion

Chronicle Map est une solution puissante pour les applications Java nécessitant des performances déterministes et une gestion mémoire hors tas. Que vous travailliez dans le trading haute fréquence, la mise en cache distribuée ou les systèmes temps réel, cette bibliothèque vous offre un contrôle précis sur l'allocation mémoire et des latences minimales.

N'hésitez pas à consulter la documentation officielle sur GitHub pour des cas d'usage plus avancés, comme l'utilisation de clés composites ou la réplication entre instances.