"Bitte erläutern Sie den Unterschied zwischen StringBuilder und StringBuffer." Sagte, "String Builder hat eine bessere Leistung !!" Ich konnte nur antworten.
Dieses Mal habe ich versucht zu überprüfen, warum StringBuilder eine gute Leistung hat und wie groß der Geschwindigkeitsunterschied ist.
StringBuilder: Nicht threadsicher StringBuffer: Thread-sicher
Das war alles. Laut Tiger, der StringBuilder eingeführt hat "Benötigen Sie einen Thread-Safe für die Verkettung von Zeichenfolgen?" Es scheint, dass es mit der Idee gemacht wurde.
String Manipulation Thread Safe vs Performance StringBuilder
Sicherlich habe ich noch nie eine String-Verkettung gesehen, die Thread-Sicherheit erfordert. Viele Leute haben es ohne große Sorge benutzt, aber ich finde es erstaunlich, es zu fangen.
Ich habe versucht, es leicht zu überprüfen. Wir haben diese Überprüfungsmethode übernommen. [Java] Ich habe versucht, den Unterschied zwischen StringBuilder und StringBuffer unter dem Gesichtspunkt der Thread-Sicherheit zu überprüfen
Teilen Sie dieselbe StringBuilder / StringBuffer-Instanz mit 100 Threads und wiederholen Sie das Anhängen 10.000 Mal. Infolgedessen sehen wir, ob length () korrekt 1 Million beträgt. Die Verarbeitungsgeschwindigkeit wurde ebenfalls gemessen.
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
Mit StringBuilder ging fast die Hälfte der Zeichen verloren. Stattdessen ist die Verarbeitungsgeschwindigkeit etwa fünfmal schneller.
Es ist immer noch unwahrscheinlich, dass ich im realen Geschäft eine thread-sichere String-Verkettung benötige. Daher werde ich StringBuilder mit Schwerpunkt auf Leistung verwenden.
Recommended Posts