Pourquoi utiliser StringBuilder? StringBuffer peut fonctionner avec plusieurs threads ainsi qu'un thread?

Supposons que notre application ont qu'un seul thread. et nous utilisons StringBuffer alors quel est le problème?

Je veux dire, si StringBuffer peut gérer plusieurs threads grâce à la synchronisation, quel est le problème à travailler avec un seul fil?

Pourquoi utiliser StringBuilder à la place?

source d'informationauteur MANISH PATHAK

  1. 26

    StringBuffers sont thread-safe, ce qui signifie qu'ils ont synchronisé méthodes de contrôle de l'accès, de sorte qu'un seul thread peut accéder à un objet StringBuffer synchronisées de code à la fois. Ainsi, StringBuffer objets sont généralement sans danger pour une utilisation dans un environnement multi-threads où plusieurs threads peuvent être en train d'essayer d'accéder à la même StringBuffer objet en même temps.

    StringBuilder's l'accès n'est pas synchronisés, de sorte qu'il n'est pas thread-safe. En n'étant pas synchronisés, les performances de StringBuilder peut être mieux que StringBuffer. Ainsi, si vous travaillez dans un seul thread de l'environnement, à l'aide de StringBuilder au lieu de StringBuffer peut entraîner une augmentation des performances. C'est aussi vrai pour d'autres situations, comme un StringBuilder variable locale (c'est à dire, une variable à l'intérieur d'une méthode), où un seul thread va être accéder à un objet StringBuilder.

    Donc, préfèrent StringBuilder parce que,

    • Petit gain de performance.
    • StringBuilder est de 1:1 goutte en remplacement de la classe StringBuffer.
    • StringBuilder est pas thread-synchronisé et donc de meilleures performances sur la plupart des implémentations de Java

    Check this out :

  2. 7

    StringBuilder est censé être un (petit) peu plus vite car il n'est pas synchronisée (thread-safe).

    Vous pouvez remarquer la différence de vraiment lourd applications.

    La classe StringBuilder doit généralement être utilisé de préférence à celui-ci, car il prend en charge tous les mêmes opérations, mais il est plus rapide, car il n'effectue aucune synchronisation.

    http://download.oracle.com/javase/6/docs/api/java/lang/StringBuffer.html

  3. 4

    À l'aide de StringBuffer dans plusieurs threads est à côté de rien et, en réalité, n'arrive presque jamais.

    De considérer les éléments suivants

    Thread1: sb.append(key1).append("=").append(value1);
Thread2: sb.append(key2).append("=").append(value2);

    chaque ajout est synchronisé, mais un thread peut s'abaisser à tout moment de sorte que vous pouvez avoir toutes les combinaisons suivantes et plus

    key1=value1key2=value2
key1key2==value2value1
key2key1=value1=value2
key2=key1=value2value1

    Cela peut être évité par la synchronisation de l'ensemble de la ligne à un moment, mais cela va à l'encontre du point de l'utilisation de StringBuffer au lieu de StringBuilder.

    Même si vous avez correctement synchronisé vue, il est plus compliqué que la simple création d'un thread copie locale de l'ensemble de la ligne par exemple StringBuilder et les lignes du journal à un moment à une classe comme un Écrivain.

  4. 3

    StringBuffer n'est pas mal dans un seul thread de l'application. Il fonctionnera tout aussi bien que StringBuilder.

    La seule différence est la petite surcharge ajoutée en ayant toutes les méthodes synchronisées, ce qui n'apporte aucun avantage dans un seul thread de l'application.

    Mon avis est que le principal raison StringBuilder a été introduit, c'est que le compilateur utilise StringBuffer (et maintenant StringBuilder) lorsqu'il compile le code qui contient String concaténation: dans ce cas, la synchronisation est jamais nécessaire et le remplacement de tous ces lieux avec une liste non-synchronisé StringBuilder peut fournir une petite amélioration de la performance.

  5. 2

    StringBuilder a une meilleure performance parce que c'est les méthodes ne sont pas synchronisés.

    Donc, si vous n'avez pas besoin de construire une Chaîne de caractères simultanément (ce qui est un peu atypique scénario de toute façon), alors il n'y a pas besoin de "payer" pour la synchronisation inutile de frais généraux.

  6. 0

    Cela aidera u les gars,
    Être Droit Builder est plus rapide que la mémoire Tampon, 

    public class ConcatPerf {
private static final int ITERATIONS = 100000;
private static final int BUFFSIZE = 16;
private void concatStrAdd() {
System.out.print("concatStrAdd   -> ");
long startTime = System.currentTimeMillis();
String concat = new String("");
for (int i = 0; i < ITERATIONS; i++) {
concat += i % 10;
}
//System.out.println("Content: " + concat);
long endTime = System.currentTimeMillis();
System.out.print("length: " + concat.length());
System.out.println(" time: " + (endTime - startTime));
}
private void concatStrBuff() {
System.out.print("concatStrBuff  -> ");
long startTime = System.currentTimeMillis();
StringBuffer concat = new StringBuffer(BUFFSIZE);
for (int i = 0; i < ITERATIONS; i++) {
concat.append(i % 10);
}
long endTime = System.currentTimeMillis();
//System.out.println("Content: " + concat);
System.out.print("length: " + concat.length());
System.out.println(" time: " + (endTime - startTime));
}
private void concatStrBuild() {
System.out.print("concatStrBuild -> ");
long startTime = System.currentTimeMillis();
StringBuilder concat = new StringBuilder(BUFFSIZE);
for (int i = 0; i < ITERATIONS; i++) {
concat.append(i % 10);
}
long endTime = System.currentTimeMillis();
//System.out.println("Content: " + concat);
System.out.print("length: " + concat.length());
System.out.println(" time: " + (endTime - startTime));
}
public static void main(String[] args) {
ConcatPerf st = new ConcatPerf();
System.out.println("Iterations: " + ITERATIONS);
System.out.println("Buffer    : " + BUFFSIZE);
st.concatStrBuff();
st.concatStrBuild();
st.concatStrAdd();
}
}
Output  
run:
Iterations: 100000
Buffer    : 16
concatStrBuff  -> length: 100000 time: 11
concatStrBuild -> length: 100000 time: 4
concatStrAdd   ->
  7. 0

    Manish, bien qu'il y a juste un thread d'exploitation sur votre StringBuffer exemple, il y a une surcharge de l'acquisition et de libérer le moniteur de verrouillage sur le StringBuffer exemple à chaque fois que ses méthodes sont invoquées. Donc StringBuilder est un meilleur choix dans un seul thread de l'environnement.

  8. 0

    Il y a un coût énorme pour synchroniser les objets. De ne pas voir un programme en tant qu'entité autonome; ce n'est pas un problème lors de la lecture des concepts et de les appliquer sur des petits programmes comme vous l'avez mentionné dans votre question, les détails, les problèmes surviennent lorsque nous voulons à l'échelle du système. Dans ce cas, votre seul thread programme pourrait dépendre de plusieurs autres méthodes, des programmes et des entités, de sorte que des objets synchronisés peut causer une grave programmation de la complexité en termes de performances. Donc, si vous êtes sûr qu'il n'est pas nécessaire de synchroniser un objet, alors vous devriez utiliser StringBuilder que c'est une bonne programmation. À la fin, nous voulons apprendre la programmation pour faire évolutive de systèmes de haute performance, de sorte que c'est ce que nous devrions faire!