Java 中的 StringBuilder 与 StringBuffer-java教程-PHP中文网

StringBuilder vs StringBuffer in Java

在 Java 中，当使用可变字符串（可以修改的字符串）时，您可能需要在 StringBuilder 和 StringBuffer 之间进行选择。虽然两者都是允许修改其值的可变类，但它们在线程安全、性能和应用程序方面存在显着差异。在这里，我们将比较它们的特性并提供代码示例来说明何时使用它们。

主要区别：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

可变性可变可变存储在堆（不使用字符串池）堆（不使用字符串池）线程安全非线程安全线程安全同步未同步已同步性能更快由于缺乏同步由于同步开销而变慢用例单线程场景需要线程安全的多线程场景表>

让我们更详细地探索每个课程。

1. StringBuilder：单线程环境的高效选择

StringBuilder 是一个可变类，这意味着它允许修改其内容。
它是线程不安全，因此它非常适合单线程场景。
未同步：由于没有同步开销，StringBuilder 比 StringBuffer 更快。
多线程限制：在没有额外安全措施的多线程环境中使用 StringBuilder 可能会导致竞争条件和其他并发问题。

示例：演示 StringBuilder 中的线程不安全性

在此示例中，我们使用两个线程将字符附加到 StringBuilder 实例。然而，由于缺乏同步，我们遇到了竞争条件：

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

登录后复制

说明：

由于线程不安全，StringBuilder 输出的最终长度是不可预测的（例如，1840 而不是 2000）。
发生这种情况是因为两个线程都尝试同时追加字符，导致覆盖或删除操作。

要点：仅在单线程环境中或在外部处理线程安全时使用 StringBuilder。

2. StringBuffer：多线程环境的安全选择

StringBuffer 是可变的，允许修改其内容。
它是同步，这使得它线程安全。
非常适合需要线程安全的多线程环境。
性能成本：同步会带来开销，因此 StringBuffer 比 StringBuilder 慢。

示例：StringBuffer 中的线程安全

这里是与上面相同的示例，但这次使用 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();
    }
}

登录后复制

说明：