StringBuilder vs. StringBuffer in Java

Wenn Sie in Java mit veränderlichen Strings (Strings, die geändert werden können) arbeiten, müssen Sie möglicherweise zwischen StringBuilder und StringBuffer wählen. Obwohl es sich bei beiden um veränderliche Klassen handelt, die eine Änderung ihrer Werte ermöglichen, unterscheiden sie sich erheblich in Bezug auf Thread-Sicherheit, Leistung und Anwendung. Hier vergleichen wir ihre Eigenschaften und stellen Codebeispiele bereit, um zu veranschaulichen, wann sie jeweils verwendet werden sollten.

---

Hauptunterschiede: StringBuilder vs. StringBuffer

Funktion StringBuilder StringBuffer

Feature	StringBuilder	StringBuffer
Mutability	Mutable	Mutable
Stored in	Heap (does not use String Pool)	Heap (does not use String Pool)
Thread Safety	Not thread-safe	Thread-safe
Synchronization	Not synchronized	Synchronized
Performance	Faster due to lack of synchronization	Slower due to synchronization overhead
Use Case	Single-threaded scenarios	Multi-threaded scenarios where thread-safety is required

Veränderlichkeit Veränderlich Veränderlich Gespeichert in Heap (verwendet keinen String-Pool) Heap (verwendet keinen String-Pool) Thread-Sicherheit Nicht threadsicher Thread-sicher Synchronisierung Nicht synchronisiert Synchronisiert Leistung Schneller aufgrund fehlender Synchronisierung Langsamer aufgrund des Synchronisierungsaufwands Anwendungsfall Single-Thread-Szenarien Multithread-Szenarien, in denen Thread-Sicherheit erforderlich ist

Lassen Sie uns jede Klasse genauer untersuchen.

---

1. StringBuilder: Die effiziente Wahl für Single-Threaded-Umgebungen

• StringBuilder ist eine veränderliche Klasse, was bedeutet, dass sie Änderungen an ihrem Inhalt zulässt.

• Es ist Thread-unsicher und eignet sich daher ideal für Single-Threaded-Szenarien.

• Nicht synchronisiert: StringBuilder ist aufgrund des fehlenden Synchronisierungsaufwands schneller als StringBuffer.

• Multithread-Einschränkung: Die Verwendung von StringBuilder in Multithread-Umgebungen ohne zusätzliche Sicherheitsmaßnahmen kann zu Race Conditions und anderen Parallelitätsproblemen führen.

Beispiel: Demonstration der Thread-Unsicherheit in StringBuilder

In diesem Beispiel verwenden wir zwei Threads, um Zeichen an eine StringBuilder-Instanz anzuhängen. Aufgrund der fehlenden Synchronisierung treten jedoch Race Conditions auf:

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();
    }
}

Erklärung:

• Aufgrund der Thread-Unsicherheit ist die endgültige Länge der StringBuilder-Ausgabe unvorhersehbar (z. B. 1840 statt 2000).

• Dies geschieht, weil beide Threads versuchen, Zeichen gleichzeitig anzuhängen, was zu Überschreibungen oder abgebrochenen Vorgängen führt.

Takeaway: Verwenden Sie StringBuilder nur in Single-Thread-Umgebungen oder wenn die Thread-Sicherheit extern gehandhabt wird.

---

2. StringBuffer: Die sichere Option für Multithread-Umgebungen

• StringBuffer ist veränderlich und ermöglicht Änderungen an seinem Inhalt.

• Es ist synchronisiert, was es Thread-sicher macht.

• Ideal für Multithread- Umgebungen, in denen Thread-Sicherheit erforderlich ist.

• Leistungskosten: Die Synchronisierung führt zu Mehraufwand, daher ist StringBuffer langsamer als StringBuilder.

Beispiel: Thread-Sicherheit in StringBuffer

Hier ist das gleiche Beispiel wie oben, aber dieses Mal mit 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();
    }
}

Erklärung:

• StringBuffer stellt sicher, dass beide Threads sicher angehängt werden und die erwartete Länge von 2000 erreicht wird.

• Während die endgültige Zeichenfolge threadsicher ist, kann die Ausgabe verschachtelt sein (z. B. „AAABBB...“ gemischt), da die Thread-Ausführungsreihenfolge nicht deterministisch.

Takeaway: Verwenden Sie StringBuffer für Multithread-Anwendungen, bei denen die Datenkonsistenz entscheidend ist und eine Synchronisierung erforderlich ist.

---

Die richtige Klasse wählen

Um zwischen StringBuilder und StringBuffer zu entscheiden, berücksichtigen Sie Folgendes:

• Verwenden Sie StringBuilder in Single-Thread-Szenarien, in denen die Leistung entscheidend ist und die Thread-Sicherheit kein Problem darstellt.

• Verwenden Sie StringBuffer in Multithread-Szenarien, in denen Sie veränderbare String-Operationen und Thread-Sicherheit benötigen, um Race Conditions zu vermeiden.

---

Abschluss

Dieser Vergleich soll Ihnen helfen, eine fundierte Wahl zwischen StringBuilder und StringBuffer zu treffen. Das Verständnis der Kompromisse in Bezug auf Veränderlichkeit, Leistung und Thread-Sicherheit kann zu einer besseren Entscheidungsfindung bei der Arbeit mit Strings in Java führen.

---

Verwandte Beiträge

• Java-Grundlagen
• Array Interview Essentials
• Java Memory Essentials
• Java Keywords Essentials
• Java OOPs Essentials
• Collections Framework Essentials

Viel Spaß beim Codieren!

Das obige ist der detaillierte Inhalt vonStringBuilder vs. StringBuffer in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!