StringBuilder contre StringBuffer en Java

En Java, lorsque vous travaillez avec des chaînes mutables (chaînes pouvant être modifiées), vous devrez peut-être choisir entre StringBuilder et StringBuffer. Bien que les deux soient des classes mutables qui permettent de modifier leurs valeurs, elles diffèrent considérablement en termes de sécurité des threads, performances et application. Ici, nous comparerons leurs caractéristiques et fournirons des exemples de code pour illustrer quand utiliser chacun d’eux.

---

Différences clés : StringBuilder et StringBuffer

Fonctionnalité StringBuilder StringBuffer ête>

Feature	StringBuilder	StringBuffer
Mutability	Mutable	Mutable
Stored in	Heap (does not use String Pool)	Heap (does not use String Pool)
Thread Safety	Not thread-safe	Thread-safe
Synchronization	Not synchronized	Synchronized
Performance	Faster due to lack of synchronization	Slower due to synchronization overhead
Use Case	Single-threaded scenarios	Multi-threaded scenarios where thread-safety is required

Mutabilité Mutable Mutable Stocké dans Heap (n'utilise pas le pool de chaînes) Heap (n'utilise pas le pool de chaînes) Sécurité des fils Pas thread-safe Thread-safe Synchronisation Non synchronisé Synchronisé Performances Plus rapide en raison du manque de synchronisation Plus lent en raison de la surcharge de synchronisation Cas d'utilisation Scénarios monothread Scénarios multithread où la sécurité des threads est requise

Explorons chaque classe plus en détail.

---

1. StringBuilder : le choix efficace pour les environnements monothread

• StringBuilder est une classe mutable, ce qui signifie qu'elle permet de modifier son contenu.

• Il est thread-unsafe, il est donc idéal pour les scénarios à thread unique.

• Non synchronisé : StringBuilder est plus rapide que StringBuffer en raison de l'absence de surcharge de synchronisation.

• Limitation multithread : L'utilisation de StringBuilder dans des environnements multithread sans mesures de sécurité supplémentaires peut entraîner des conditions de concurrence et d'autres problèmes de concurrence.

Exemple : démonstration de la non-sécurité des threads dans StringBuilder

Dans cet exemple, nous utilisons deux threads pour ajouter des caractères à une instance StringBuilder. Cependant, du fait du manque de synchronisation, nous rencontrons des conditions de course :

public class StringBuilderBasics {

    public void threadUnsafe() {
        // Common resource being shared
        StringBuilder builder = new StringBuilder();

        // Thread appending "A" 1000 times
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                builder.append("A");
            }
        });

        // Thread appending "B" 1000 times
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                builder.append("B");
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Result: 1840 (unpredictable)
        System.out.println("Length: " + builder.toString().length());
    }

    public static void main(String[] args) {
        new StringBuilderBasics().threadUnsafe();
    }
}

Explication :

• En raison d'un risque de thread, la longueur finale de la sortie StringBuilder est imprévisible (par exemple, 1840 au lieu de 2000).

• Cela se produit parce que les deux threads tentent d'ajouter des caractères simultanément, ce qui entraîne des écrasements ou des opérations supprimées.

À retenir : utilisez StringBuilder uniquement dans des environnements monothread ou lorsque la sécurité des threads est gérée en externe.

---

2. StringBuffer : l'option sûre pour les environnements multithread

• StringBuffer est mutable, permettant des modifications de son contenu.

• Il est synchronisé, ce qui le rend thread-safe.

• Idéal pour les environnements multi-thread où la sécurité des threads est nécessaire.

• Coût de performance : la synchronisation introduit une surcharge, donc StringBuffer est plus lent que StringBuilder.

Exemple : sécurité des threads dans StringBuffer

Voici le même exemple que ci-dessus, mais cette fois en utilisant StringBuffer :

public class StringBufferBasics {

    public void threadSafe() {
        // Common resource being shared
        StringBuffer buffer = new StringBuffer();

        // Thread appending "A" 1000 times
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                buffer.append("A");
            }
        });

        // Thread appending "B" 1000 times
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                buffer.append("B");
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // Result: 2000
        System.out.println("Length: " + buffer.toString().length());
    }

    public static void main(String[] args) {
        new StringBufferBasics().threadSafe();
    }
}

Explication :

• StringBuffer garantit que les deux threads s'ajoutent en toute sécurité, atteignant la longueur attendue de 2000.

• Bien que la chaîne finale soit thread-safe, la sortie peut être entrelacée (par exemple, "AAABBB..." mélangés) car l'ordre d'exécution des threads est non déterministe.

À retenir : utilisez StringBuffer pour les applications multithread où la cohérence des données est cruciale et la synchronisation est nécessaire.

---

Choisir la bonne classe

Pour choisir entre StringBuilder et StringBuffer, considérez ce qui suit :

• Utilisez StringBuilder dans des scénarios à thread unique où les performances sont critiques et où la sécurité des threads n'est pas un problème.

• Utilisez StringBuffer dans des scénarios multithread où vous avez besoin d'opérations de chaîne mutables et exigez la sécurité des threads pour éviter les conditions de concurrence.

---

Conclusion

Cette comparaison devrait vous aider à faire un choix éclairé entre StringBuilder et StringBuffer. Comprendre les compromis en matière de mutabilité, de performances et de sécurité des threads peut conduire à une meilleure prise de décision lorsque vous travaillez avec des chaînes en Java.

---

Articles connexes

• Fondamentaux de Java
• Les essentiels de l'entretien avec Array
• L'essentiel de la mémoire Java
• L'essentiel des mots-clés Java
• L'essentiel de Java OOP
• L'essentiel du cadre de collections

Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!