Différence entre SsortingngBuilder et SsortingngBuffer

Quelle est la principale différence entre SsortingngBuffer et SsortingngBuilder ? Y a-t-il des problèmes de performance lors de la décision?

SsortingngBuffer est synchronisé, SsortingngBuilder ne l’est pas.

SsortingngBuilder est plus rapide que SsortingngBuffer car il n’est pas synchronized .

Voici un test de référence simple:

 public class Main { public static void main(Ssortingng[] args) { int N = 77777777; long t; { SsortingngBuffer sb = new SsortingngBuffer(); t = System.currentTimeMillis(); for (int i = N; i --> 0 ;) { sb.append(""); } System.out.println(System.currentTimeMillis() - t); } { SsortingngBuilder sb = new SsortingngBuilder(); t = System.currentTimeMillis(); for (int i = N; i > 0 ; i--) { sb.append(""); } System.out.println(System.currentTimeMillis() - t); } } } 

Un test donne les nombres de 2241 ms pour SsortingngBuffer vs 753 ms pour SsortingngBuilder .

Fondamentalement, les méthodes SsortingngBuffer sont synchronisées, contrairement à SsortingngBuilder .

Les opérations sont “presque” les mêmes, mais l’utilisation de méthodes synchronisées dans un seul thread est excessive.

C’est à peu près tout.

Citation de l’ API SsortingngBuilder :

Cette classe [SsortingngBuilder] fournit une API compatible avec SsortingngBuffer, mais sans garantie de synchronisation . Cette classe est conçue pour remplacer SsortingngBuffer dans les endroits où le tampon de chaîne était utilisé par un seul thread (comme c’est généralement le cas). Dans la mesure du possible, il est recommandé d’utiliser cette classe de préférence à SsortingngBuffer car elle sera plus rapide dans la plupart des implémentations.

Donc, il a été fait pour le remplacer.

La même chose s’est produite avec Vector et ArrayList .

Mais il fallait faire la différence avec un exemple?

SsortingngBuffer ou SsortingngBuilder

Utilisez simplement SsortingngBuilder sauf si vous essayez vraiment de partager un tampon entre les threads. SsortingngBuilder est le frère cadet non synchronisé (moins chargé = plus efficace) de la classe SsortingngBuffer synchronisée d’origine.

SsortingngBuffer est venu en premier. Sun était préoccupé par l’exactitude dans toutes les conditions, alors ils l’ont fait synchronisé pour le rendre sûr au cas par cas.

SsortingngBuilder est venu plus tard. La plupart des utilisations de SsortingngBuffer étaient à un seul thread et payaient inutilement le coût de la synchronisation.

Puisque SsortingngBuilder est un remplacement SsortingngBuffer pour SsortingngBuffer sans la synchronisation, il n’y aurait pas de différences entre les exemples.

Si vous essayez de partager entre les threads, vous pouvez utiliser SsortingngBuffer , mais déterminez si une synchronisation de haut niveau est nécessaire, par exemple au lieu d’utiliser SsortingngBuffer, si vous synchronisez les méthodes qui utilisent SsortingngBuilder.

Tout d’abord, voyons les similitudes : les deux SsortingngBuilder et SsortingngBuffer sont mutables. Cela signifie que vous pouvez en changer le contenu, au même endroit.

Différences : SsortingngBuffer est mutable et synchronisé. Où SsortingngBuilder est mutable mais non synchronisé par défaut.

Signification de synchronisé (synchronisation) : Lorsque quelque chose est synchronisé, plusieurs threads peuvent y accéder et le modifier sans aucun problème ou effet secondaire. SsortingngBuffer est synchronisé, vous pouvez donc l’utiliser avec plusieurs threads sans aucun problème.

Lequel utiliser quand? SsortingngBuilder: Lorsque vous avez besoin d’une chaîne, qui peut être modifiable, et qu’un seul thread accède et le modifie. SsortingngBuffer: lorsque vous avez besoin d’une chaîne pouvant être modifiable et que plusieurs threads y accèdent et la modifient.

Remarque : N’utilisez pas SsortingngBuffer inutilement, c.-à-d., Ne l’utilisez pas si un seul thread modifie et y accède car il a beaucoup de code de locking et de délocking pour la synchronisation qui prendra inutilement du temps processeur. N’utilisez pas de cadenas à moins que cela ne soit nécessaire.

Grâce aux optimisations JVM, SsortingngBuffer n’est pas significativement plus lent que SsortingngBuilder dans les threads simples. Et dans le multithreading, vous ne pouvez pas utiliser en toute sécurité SsortingngBuilder.

Voici mon test:

 public static void main(Ssortingng[] args) { Ssortingng withSsortingng =""; long t0 = System.currentTimeMillis(); for (int i = 0 ; i < 100000; i++){ withString+="some string"; } System.out.println("strings:" + (System.currentTimeMillis() - t0)); t0 = System.currentTimeMillis(); StringBuffer buf = new StringBuffer(); for (int i = 0 ; i < 100000; i++){ buf.append("some string"); } System.out.println("Buffers : "+(System.currentTimeMillis() - t0)); t0 = System.currentTimeMillis(); StringBuilder building = new StringBuilder(); for (int i = 0 ; i < 100000; i++){ building.append("some string"); } System.out.println("Builder : "+(System.currentTimeMillis() - t0)); } 

Résultats :
cordes: 319740
Tampons: 23
Builder: 7!

Les constructeurs sont donc plus rapides que les tampons et WAY plus rapides que la concaténation de chaînes. Maintenant, utilisons un exécuteur pour plusieurs threads:

 public class SsortingngsPerf { public static void main(Ssortingng[] args) { ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10); //With Buffer SsortingngBuffer buffer = new SsortingngBuffer(); for (int i = 0 ; i < 10; i++){ executorService.execute(new AppendableRunnable(buffer)); } shutdownAndAwaitTermination(executorService); System.out.println(" Thread Buffer : "+ AppendableRunnable.time); //With Builder AppendableRunnable.time = 0; executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10); StringBuilder builder = new StringBuilder(); for (int i = 0 ; i < 10; i++){ executorService.execute(new AppendableRunnable(builder)); } shutdownAndAwaitTermination(executorService); System.out.println(" Thread Builder: "+ AppendableRunnable.time); } static void shutdownAndAwaitTermination(ExecutorService pool) { pool.shutdown(); // code reduced from Official Javadoc for Executors try { if (!pool.awaitTermination(60, TimeUnit.SECONDS)) { pool.shutdownNow(); if (!pool.awaitTermination(60, TimeUnit.SECONDS)) System.err.println("Pool did not terminate"); } } catch (Exception e) {} } } class AppendableRunnable implements Runnable { static long time = 0; T appendable; public AppendableRunnable(T appendable){ this.appendable = appendable; } @Override public void run(){ long t0 = System.currentTimeMillis(); for (int j = 0 ; j < 10000 ; j++){ try { appendable.append("some string"); } catch (IOException e) {} } time+=(System.currentTimeMillis() - t0); } } 

Maintenant, SsortingngBuffers prend 157 ms pour 100000 ajouts. Ce n'est pas le même test, mais comparé aux 37 ms précédentes, vous pouvez supposer que les ajouts de SsortingngBuffers sont plus lents avec l'utilisation du multithreading . La raison en est que JIT / hotspot / comstackr / quelque fait des optimisations quand il détecte qu'il n'y a pas besoin de vérifier les verrous.

Mais avec SsortingngBuilder, vous avez une exception java.lang.ArrayIndexOutOfBoundsException , car un thread simultané tente d'append quelque chose qui ne devrait pas l'être.

La conclusion est que vous n'avez pas à chasser SsortingngBuffers. Et lorsque vous avez des threads, pensez à ce qu’ils font avant d’essayer de gagner quelques nanosecondes.

SsortingngBuilder a été introduit dans Java 1.5 afin de ne pas fonctionner avec les anciennes JVM.

Depuis les Javadocs :

La classe SsortingngBuilder fournit une API compatible avec SsortingngBuffer, mais sans garantie de synchronisation. Cette classe est conçue pour remplacer SsortingngBuffer dans les endroits où le tampon de chaîne était utilisé par un seul thread (comme c’est généralement le cas). Dans la mesure du possible, il est recommandé d’utiliser cette classe de préférence à SsortingngBuffer car elle sera plus rapide dans la plupart des implémentations.

Assez bonne question

Voici les différences, j’ai remarqué:

SsortingngBuffer: –

 SsortingngBuffer is synchronized SsortingngBuffer is thread-safe SsortingngBuffer is slow (try to write a sample program and execute it, it will take more time than SsortingngBuilder) 

SsortingngBuilder: –

  SsortingngBuilder is not synchronized SsortingngBuilder is not thread-safe SsortingngBuilder performance is better than SsortingngBuffer. 

Chose banale :-

Les deux ont les mêmes méthodes avec les mêmes signatures. Les deux sont mutables.

SsortingngBuilder n’est pas thread-safe. Chaîne tampon est. Plus d’infos ici .

EDIT: En ce qui concerne la performance, après le lancement du hotspot , SsortingngBuilder est le gagnant. Cependant, pour les petites itérations, la différence de performance est négligeable.

SsortingngBuilder et SsortingngBuffer sont presque les mêmes. La différence est que SsortingngBuffer est synchronisé et que SsortingngBuilder ne l’est pas. Bien que SsortingngBuilder soit plus rapide que SsortingngBuffer , la différence de performances est très faible. SsortingngBuilder est un remplacement SUN de SsortingngBuffer . Cela évite simplement la synchronisation de toutes les méthodes publiques. Plutôt que cela, leur fonctionnalité est la même.

Exemple de bon usage:

Si votre texte va changer et est utilisé par plusieurs threads, il est préférable d’utiliser SsortingngBuffer . Si votre texte va changer mais est utilisé par un seul thread, utilisez alors SsortingngBuilder .

SsortingngBuffer

SsortingngBuffer est mutable signifie que l’on peut changer la valeur de l’object. L’object créé via SsortingngBuffer est stocké dans le tas. SsortingngBuffer a les mêmes méthodes que SsortingngBuilder, mais chaque méthode de SsortingngBuffer est synchronisée, c’est-à-dire que SsortingngBuffer est thread-safe.

de ce fait, il ne permet pas à deux threads d’accéder simultanément à la même méthode. Chaque méthode est accessible par un thread à la fois.

Mais la sécurité des threads présente également des inconvénients, car les performances de SsortingngBuffer sont dues à la propriété thread-safe. Ainsi SsortingngBuilder est plus rapide que le SsortingngBuffer lors de l’appel des mêmes méthodes de chaque classe.

La valeur de SsortingngBuffer peut être modifiée, cela signifie qu’elle peut être affectée à la nouvelle valeur. Aujourd’hui, c’est une question d’interview la plus courante, les différences entre les classes ci-dessus. Ssortingng Buffer peut être converti en chaîne en utilisant la méthode toSsortingng ().

 SsortingngBuffer demo1 = new SsortingngBuffer(“Hello”) ; // The above object stored in heap and its value can be changed . demo1=new SsortingngBuffer(“Bye”); // Above statement is right as it modifies the value which is allowed in the SsortingngBuffer 

SsortingngBuilder

SsortingngBuilder est identique à SsortingngBuffer, c’est-à-dire qu’il stocke l’object dans le tas et qu’il peut également être modifié. La principale différence entre SsortingngBuffer et SsortingngBuilder est que SsortingngBuilder n’est pas non plus compatible avec les threads. SsortingngBuilder est rapide car il n’est pas thread-safe.

 SsortingngBuilder demo2= new SsortingngBuilder(“Hello”); // The above object too is stored in the heap and its value can be modified demo2=new SsortingngBuilder(“Bye”); // Above statement is right as it modifies the value which is allowed in the SsortingngBuilder 

entrer la description de l'image ici

Ressource: Ssortingng vs SsortingngBuffer Vs SsortingngBuilder

SsortingngBuffer

  • Synchronisé donc threadsafe
  • fil sûr donc lent

SsortingngBuilder

  • Introduit dans Java 5.0
  • Asynchrone donc rapide et efficace
  • L’utilisateur doit explicitement le synchroniser s’il le souhaite
  • Vous pouvez le remplacer SsortingngBuilder sans autre changement

Ssortingng est un immuable.

SsortingngBuffer est un mutable et synchronisé.

SsortingngBuilder est également mutable mais n’est pas synchronisé.

Le javadoc explique la différence:

Cette classe fournit une API compatible avec SsortingngBuffer, mais sans garantie de synchronisation. Cette classe est conçue pour remplacer SsortingngBuffer dans les endroits où le tampon de chaîne était utilisé par un seul thread (comme c’est généralement le cas). Dans la mesure du possible, il est recommandé d’utiliser cette classe de préférence à SsortingngBuffer car elle sera plus rapide dans la plupart des implémentations.

SsortingngBuilder (introduit dans Java 5) est identique à SsortingngBuffer , sauf que ses méthodes ne sont pas synchronisées. Cela signifie qu’il a de meilleures performances que ce dernier, mais l’inconvénient est qu’il n’est pas compatible avec les threads.

Lisez le tutoriel pour plus de détails.

SsortingngBuilder est beaucoup plus rapide que SsortingngBuffer car il n’est pas synchronisé.

Ici vous avez plus d’idée sur le coût de la synchronisation

Laisser prendre par programme combien SsortingngBuilder est plus rapide que SsortingngBuffer

 public class Test{ public static void main(Ssortingng[] args){ long startTime = System.currentTimeMillis(); SsortingngBuffer sb = new SsortingngBuffer("Yasir"); for (int i=0; i<10000; i++){ sb.append("Shabbir"); } System.out.println("Time taken by StringBuffer: " + (System.currentTimeMillis() - startTime) + "ms"); startTime = System.currentTimeMillis(); StringBuilder sb2 = new StringBuilder("Yasir"); for (int i=0; i<10000; i++){ sb2.append("Shabbir"); } System.out.println("Time taken by StringBuilder: " + (System.currentTimeMillis() - startTime) + "ms"); } } 

Sortie

Temps pris par SsortingngBuffer: 16ms

Temps pris par SsortingngBuilder: 0ms

Un programme simple illustrant la différence entre SsortingngBuffer et SsortingngBuilder:

 /** * Run this program a couple of times. We see that the SsortingngBuilder does not * give us reliable results because its methods are not thread-safe as compared * to SsortingngBuffer. * * For example, the single append in SsortingngBuffer is thread-safe, ie * only one thread can call append() at any time and would finish writing * back to memory one at a time. In contrast, the append() in the SsortingngBuilder * class can be called concurrently by many threads, so the final size of the * SsortingngBuilder is sometimes less than expected. * */ public class SsortingngBufferVSSsortingngBuilder { public static void main(Ssortingng[] args) throws InterruptedException { int n = 10; //*************************Ssortingng Builder Test*******************************// SsortingngBuilder sb = new SsortingngBuilder(); SsortingngBuilderTest[] builderThreads = new SsortingngBuilderTest[n]; for (int i = 0; i < n; i++) { builderThreads[i] = new StringBuilderTest(sb); } for (int i = 0; i < n; i++) { builderThreads[i].start(); } for (int i = 0; i < n; i++) { builderThreads[i].join(); } System.out.println("StringBuilderTest: Expected result is 1000; got " + sb.length()); //*************************String Buffer Test*******************************// StringBuffer sb2 = new StringBuffer(); StringBufferTest[] bufferThreads = new StringBufferTest[n]; for (int i = 0; i < n; i++) { bufferThreads[i] = new StringBufferTest(sb2); } for (int i = 0; i < n; i++) { bufferThreads[i].start(); } for (int i = 0; i < n; i++) { bufferThreads[i].join(); } System.out.println("StringBufferTest: Expected result is 1000; got " + sb2.length()); } } // Every run would attempt to append 100 "A"s to the StringBuilder. class StringBuilderTest extends Thread { StringBuilder sb; public StringBuilderTest (StringBuilder sb) { this.sb = sb; } @Override public void run() { for (int i = 0; i < 100; i++) { sb.append("A"); } } } //Every run would attempt to append 100 "A"s to the StringBuffer. class StringBufferTest extends Thread { StringBuffer sb2; public StringBufferTest (StringBuffer sb2) { this.sb2 = sb2; } @Override public void run() { for (int i = 0; i < 100; i++) { sb2.append("A"); } } } 

Mieux vaut utiliser SsortingngBuilder car il n’est pas synchronisé et donc de meilleures performances. SsortingngBuilder est un remplacement instantané de l’ancien SsortingngBuffer.

SsortingngBuffer est synchronisé, mais SsortingngBuilder ne l’est pas. Par conséquent, SsortingngBuilder est plus rapide que SsortingngBuffer .

SsortingngBuffer est mutable. Cela peut changer en termes de longueur et de contenu. SsortingngBuffers est compatible avec les threads, ce qui signifie qu’ils ont des méthodes synchronisées pour contrôler l’access afin qu’un seul thread puisse accéder au code synchronisé d’un object SsortingngBuffer à la fois. Ainsi, les objects SsortingngBuffer peuvent généralement être utilisés dans un environnement multithread où plusieurs threads peuvent tenter d’accéder au même object SsortingngBuffer en même temps.

SsortingngBuilder La classe SsortingngBuilder est très similaire à SsortingngBuffer, sauf que son access n’est pas synchronisé, de sorte qu’il n’est pas compatible avec les threads. En n’étant pas synchronisé, les performances de SsortingngBuilder peuvent être meilleures que celles de SsortingngBuffer. Ainsi, si vous travaillez dans un environnement mono-thread, l’utilisation de SsortingngBuilder au lieu de SsortingngBuffer peut entraîner une augmentation des performances. Cela est également vrai pour d’autres situations telles qu’une variable locale SsortingngBuilder (c’est-à-dire une variable dans une méthode) où un seul thread aura access à un object SsortingngBuilder.

SsortingngBuffer

SsortingngBuffer est mutable signifie que l’on peut changer la valeur de l’object. L’object créé via SsortingngBuffer est stocké dans le tas. SsortingngBuffer a les mêmes méthodes que SsortingngBuilder, mais chaque méthode de SsortingngBuffer est synchronisée, c’est-à-dire que SsortingngBuffer est thread-safe.

SsortingngBuilder

SsortingngBuilder est identique à SsortingngBuffer, c’est-à-dire qu’il stocke l’object dans le tas et qu’il peut également être modifié. La principale différence entre SsortingngBuffer et SsortingngBuilder est que SsortingngBuilder n’est pas compatible avec les threads. SsortingngBuilder est rapide car il n’est pas thread-safe.

SsortingngBuffer:

  • Multi-thread
  • Synchronisé
  • Lent que SsortingngBuilder

SsortingngBuilder

  • Fil unique
  • Non synchronisé
  • Plus rapide que jamais

Ssortingng-Builder :

 int one = 1; Ssortingng color = "red"; SsortingngBuilder sb = new SsortingngBuilder(); sb.append("One=").append(one).append(", Color=").append(color).append('\n'); System.out.print(sb); // Prints "One=1, Colour=red" followed by an ASCII newline. 

Chaîne-tampon

 SsortingngBuffer sBuffer = new SsortingngBuffer("test"); sBuffer.append(" Ssortingng Buffer"); System.out.println(sBuffer); 

Il est recommandé d’utiliser SsortingngBuilder autant que possible car il est plus rapide que SsortingngBuffer. Cependant, si la sécurité des threads est nécessaire, la meilleure option est les objects SsortingngBuffer.

SsortingngBuffer est utilisé pour stocker des chaînes de caractères qui seront modifiées (les objects Ssortingng ne peuvent pas être modifiés). Il se développe automatiquement au besoin. Classes associées: Ssortingng, CharSequence.

SsortingngBuilder a été ajouté à Java 5. Il est identique à tous égards à SsortingngBuffer sauf qu’il n’est pas synchronisé, ce qui signifie que si plusieurs threads y accèdent en même temps, il pourrait y avoir des problèmes. Dans le cas des programmes à thread unique, le cas le plus courant, à savoir éviter la surcharge de synchronisation, accélère considérablement la génération de SsortingngBuilder.

Il n’y a pas de différences fondamentales entre SsortingngBuilder et SsortingngBuffer, seules quelques différences existent entre elles. Dans SsortingngBuffer, les méthodes sont synchronisées. Cela signifie qu’à la fois un seul thread peut fonctionner sur eux. S’il y a plusieurs threads, le deuxième thread devra attendre que le premier se termine et le troisième devra attendre que le premier et le second se terminent, et ainsi de suite. Cela rend le processus très lent et donc les performances dans le cas de SsortingngBuffer sont faibles.

D’autre part, SsortingngBuilder n’est pas synchronisé. Cela signifie qu’à la fois, plusieurs threads peuvent fonctionner simultanément sur le même object SsortingnBuilder. Cela rend le processus très rapide et donc les performances de SsortingngBuilder sont élevées.

Puisque SsortingngBuffer est synchronisé, il nécessite un effort supplémentaire, donc basé sur la perforamance, c’est un peu lent que SsortingngBuilder .

Ssortingng est un object immuable, ce qui signifie que la valeur ne peut pas être modifiée lorsque SsortingngBuffer est modifiable.

SsortingngBuffer est synchronisé, ce qui signifie que SsortingngBuilder n’est pas adapté aux instances à un seul thread.

La principale différence est que SsortingngBuffer est synchronisé mais que SsortingngBuilder est pas. Si vous devez utiliser plusieurs threads, alors SsortingngBuffer est recommandé. Mais, selon la vitesse d’exécution, SsortingngBuilder est plus rapide que SsortingngBuffer , car il n’est pas synchronisé.

Vérifiez les internes de la méthode append synchronisée de SsortingngBuffer et la méthode append non synchronisée de SsortingngBuilder .

SsortingngBuffer :

 public SsortingngBuffer(Ssortingng str) { super(str.length() + 16); append(str); } public synchronized SsortingngBuffer append(Object obj) { super.append(Ssortingng.valueOf(obj)); return this; } public synchronized SsortingngBuffer append(Ssortingng str) { super.append(str); return this; } 

SsortingngBuilder :

 public SsortingngBuilder(Ssortingng str) { super(str.length() + 16); append(str); } public SsortingngBuilder append(Object obj) { return append(Ssortingng.valueOf(obj)); } public SsortingngBuilder append(Ssortingng str) { super.append(str); return this; } 

Étant donné que append est synchronized , SsortingngBuffer a une surcharge de performances par rapport à SsortingnbBuilder dans un scénario multi-threading. Tant que vous ne partagez pas de tampon entre plusieurs threads, utilisez SsortingngBuilder , qui est rapide en raison de l’absence de méthodes d’ajout synchronized .

Ce lien vous fera comprendre non seulement les concepts de SsortingngBuilder et SsortingngBuffer mais aussi leur association et leur différence avec la classe Ssortingng . Cela vous fera comprendre quand utiliser quelle classe. http://www.acquireandinspire.org/2013/01/ssortingng-ssortingng-builder-ssortingng-buffer.html