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

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!