（翻译）Difference between StringBuilder and StringBuffer

【标题】
StringBuilder 和 StringBuffer 的区别

【问题】
在使用其中一个的时候，是否存在性能问题？

【回答1】

StringBuffer是同步的，StringBuilder则不是。

【回答2】
StringBuilder运行效率会比StringBuffer快，因为它不是同步的。
这里有一个简单的基准测试。

public class Main {
    public static void main(String[] args) {
        int N = 77777777;
        long t;

        {
            StringBuffer sb = new StringBuffer();
            t = System.currentTimeMillis();
            for (int i = N; i --> 0 ;) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }

        {
            StringBuilder sb = new StringBuilder();
            t = System.currentTimeMillis();
            for (int i = N; i > 0 ; i--) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }
    }
}

测试运行给出了StringBuffer 为 2241 ms，StringBuilder 为 753 ms。

【回答3】
总的来说，StringBuffer发放是同步的，而StringBuilder不是。
这些操作“几乎”是相同的，但是在单个线程中使用同步方法是多余的。
差不多就是这样。
引用来自StringBuilder API:

此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

所以它被用来替代它。
Vector 和 ArrayList也是如此

【回答4】
在单线程中，由于JVM优化，StringBuffer不会比StringBuilder慢很多。在多线程处理中，你不能确保StringBuilder的使用安全。

这是我的测试（不是基准测试，只是测试）：

public static void main(String[] args) {

    String withString ="";
    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));
}

Results :
strings: 319740
Buffers : 23
Builder : 7 !

所以 StringBuilder比 StringBuffer更快，且都快与字符串拼接。现在，让我们使用一个线程池管理多线程。

public class StringsPerf {

    public static void main(String[] args) {

        ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        //With Buffer
        StringBuffer buffer = new StringBuffer();
        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<T extends Appendable> 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);
    }
}

现在，StringBuffers需要157ms来处理100000个拼接操作。这不是同一个测试，但是与之前的37毫秒相比，您可以安全地假设使用多线程时，StringBuffers的附加速度较慢。原因是JIT/Hotspot/Compiler/Something在检测到不需要检查锁时进行了优化。
但是使用StringBuilder就会抛出java.lang.arrayindexoutofboundsException，因为一个并发线程试图在不应该添加的地方添加一些内容。

结论是您不必跟踪StringBuffers。在你有线程的地方，在尝试获得他们的效率之前，先考虑它们在做什么。