"Veuillez expliquer la différence entre StringBuilder et StringBuffer." M'a dit, "String Builder a de meilleures performances !!" Je ne pouvais que répondre.
Donc, cette fois, j'ai essayé de vérifier pourquoi StringBuilder a de bonnes performances et quelle est la différence de vitesse.
StringBuilder: non thread-safe StringBuffer: thread safe
C'était tout. Selon Tiger, qui a introduit StringBuilder, "Avez-vous besoin de thread safe pour la concaténation de chaînes?" Il semble que cela ait été fait avec l'idée.
String Manipulation Thread Safe vs Performance StringBuilder
Certes, je n'ai jamais vu une concaténation de chaînes qui nécessite la sécurité des threads. Beaucoup de gens l'ont utilisé sans trop s'inquiéter, mais je pense que c'est incroyable de l'attraper.
J'ai essayé de le vérifier facilement. Nous avons adopté cette méthode de vérification. [Java] J'ai essayé de vérifier la différence entre StringBuilder et StringBuffer du point de vue de la sécurité des threads
Partagez la même instance StringBuilder / StringBuffer avec 100 threads et répétez l'ajout 10 000 fois. En conséquence, nous voyons si length () est correctement 1 million. La vitesse de traitement a également été mesurée.
StringBuilderTest.java
public class StringBuilderTest {
public static void main (String... args) throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(100);
StringBuilder sb = new StringBuilder();
List<BuilderTask> taskList = new ArrayList<BuilderTask>();
for(int i = 0; i < 100; i++) {
taskList.add(new BuilderTask(sb));
}
Long start = System.currentTimeMillis();
executor.invokeAll(taskList);
System.out.println("-----StringBuilder-----");
System.out.println("TAT : " + (System.currentTimeMillis() - start));
System.out.println("length() : " + sb.length());
}
static class BuilderTask implements Callable<Integer> {
private StringBuilder sb;
public BuilderTask(StringBuilder sb) {
this.sb = sb;
}
@Override
public Integer call() throws Exception {
for(int i = 0; i < 10000; i++) {
sb.append("#");
}
return null;
}
}
}
StringBufferTest.java
public class StringBufferTest {
public static void main (String... args) throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(100);
StringBuffer sb = new StringBuffer();
List<BufferTask> taskList = new ArrayList<BufferTask>();
for(int i = 0; i < 100; i++) {
taskList.add(new BufferTask(sb));
}
Long start = System.currentTimeMillis();
executor.invokeAll(taskList);
System.out.println("-----StringBuffer-----");
System.out.println("TAT : " + (System.currentTimeMillis() - start));
System.out.println("length() : " + sb.length());
}
static class BufferTask implements Callable<Integer> {
private StringBuffer sb;
public BufferTask(StringBuffer sb) {
this.sb = sb;
}
@Override
public Integer call() throws Exception {
for(int i = 0; i < 10000; i++) {
sb.append("#");
}
return null;
}
}
}
-----StringBuilder-----
TAT : 32
length() : 542861
-----StringBuffer-----
TAT : 157
length() : 1000000
Avec StringBuilder, près de la moitié des personnages ont été perdus. Au lieu de cela, la vitesse de traitement est environ 5 fois plus rapide.
Il est peu probable que j'aie besoin d'une concaténation de chaînes thread-safe dans les affaires réelles, donc je pense que j'utiliserai StringBuilder en mettant l'accent sur les performances.
Recommended Posts