StringBuffer中的每个方法都是同步的。因此，一次只允许一个线程操作StringBuffer对象。它增加了线程的等待时间并造成性能问题为了解决这个问题，SUN People推出了1.5版本的StringBuilder。

在单线程中，由于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));
}

结果：字符串：319740缓冲区：23建设者：7！

因此，构建器比缓冲区更快，比字符串串联更快。现在让我们为多个线程使用Executor：

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需要157毫秒才能完成100000次追加。这不是同一个测试，但与之前的37毫秒相比，您可以放心地假设，使用多线程时，StringBuffers追加的速度较慢。原因是JIT/hotspot/compiler/something在检测到不需要检查锁时会进行优化。

但是对于StringBuilder，您有java.lang.ArrayIndexOutOfBoundsException，因为并发线程试图在不应该添加的地方添加一些内容。

结论是，您不必追逐StringBuffers。如果您有线程，在尝试获得几纳秒之前，请考虑它们正在做什么。

字符串生成器：

int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.

字符串缓冲区

StringBuffer sBuffer = new StringBuffer("test");
sBuffer.append(" String Buffer");
System.out.println(sBuffer);  

建议尽可能使用StringBuilder，因为它比StringBuffer更快。但是，如果线程安全是必要的，最好的选择是StringBuffer对象。

字符串缓冲区

StringBuffer是可变的，这意味着可以更改对象的值。通过StringBuffer创建的对象存储在堆中。StringBuffer具有与StringBuilder相同的方法，但StringBuffer中的每个方法都是同步的，即StringBuffer是线程安全的。

因此，它不允许两个线程同时访问同一个方法。每个方法一次只能由一个线程访问。

但线程安全也有缺点，因为StringBuffer的性能由于线程安全属性而受到影响。因此，当调用每个类的相同方法时，StringBuilder比StringBuffer更快。

StringBuffer值可以更改，这意味着可以将其分配给新值。如今，这是一个最常见的面试问题，即上述课程之间的差异。字符串缓冲区可以通过使用toString（）方法。

StringBuffer demo1 = new StringBuffer(“Hello”) ;
// The above object stored in heap and its value can be changed .

demo1=new StringBuffer(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuffer

字符串拼接

StringBuilder与StringBuffer相同，即它将对象存储在堆中，也可以对其进行修改。StringBuffer和StringBuilder之间的主要区别是StringBuilder也不是线程安全的。StringBuilder速度快，因为它不是线程安全的。

StringBuilder demo2= new StringBuilder(“Hello”);
// The above object too is stored in the heap and its value can be modified

demo2=new StringBuilder(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuilder

资源：字符串Vs StringBuffer Vs StringBuilder

但需要借助一个例子来明确区别吗？StringBuffer或StringBuilder

只需使用StringBuilder，除非您确实试图在线程之间共享缓冲区。StringBuilder是原始同步StringBuffer类的非同步（开销更少=效率更高）弟弟。

StringBuffer排名第一。Sun关注所有条件下的正确性，因此他们使其同步，以使其线程安全，以防万一。

StringBuilder后来出现了。StringBuffer的大多数使用都是单线程的，不必要地支付了同步的成本。

由于StringBuilder是没有同步的StringBuffer的替代品，因此任何示例之间都不会有差异。

如果您试图在线程之间共享，可以使用StringBuffer，但要考虑是否需要更高级别的同步，例如，如果您同步使用StringBuilder的方法，可能不需要使用StringBuffer。

StringBuffer已同步，但StringBuilder未同步。因此，StringBuilder比StringBuffer更快。