先聊聊 StringBuffer，别把它当成高级黑科技

说实话，我第一次碰到 StringBuffer 那会儿，还以为它是啥高大上的缓冲区。

结果一查文档，哎呦妈呀，原来它就是个「线程安全」的可变字符串容器。

哈哈，这玩意儿在 JDK 里Yi经混迹好久了早于 StringBuilder 出场。

先把概念抖出来：String 是不可变的，每次改dou得造新对象。

而 StringBuffer 像个橡皮泥，你往里塞、拔、改，dou不会生成新实例。

这点在拼接大量字符串时省下不少 GC 的功夫。

// 错误：方法内的局部变量不会被其他线程访问
public String buildMessage {
    StringBuffer sb = new StringBuffer;  // 局部变量，只有当前线程可见
    sb.append.append;
    return sb.toString;
}
// 正确：局部变量用 StringBuilder
public String buildMessage {
    StringBuilder sb = new StringBuilder;
    sb.append.append;
    return sb.toString;
}

kan这段代码，你会发现Ru果只是单线程，用 StringBuilder geng合适；但Ru果你真的担心并发，那就得选 Buffer。

所有公开的修改方法dou加了 synchronized。

也就是说每次调用dou会先抢锁，再执行，然后立马放锁。

这叫全覆盖同步，保证同一时刻只有一个线程Neng改内部字符数组。

不过啊，这也带来了性Neng开销——每个方法dou要走一遍锁的获取和释放。

默认构造函数创建一个空缓冲区，容量是 16 个字符。

Ru果你传了初始字符串，它会把容量设成 str.length + 16，留点余地防止频繁扩容。

扩容时它会把旧数组复制到geng大的新数组里这一步也是有代价的。

.append —— 往后追加。 .insert —— 在指定位置插入。 .delete —— 删掉一段。 .reverse —— 把字符序倒过来玩玩。 .toString —— 把内部 char 转成不可变的 String，同时还有缓存机制提升读取速度。

有小伙伴常问：“我在多线程里直接用了几次 append，就算不加 synchronized，会不会出问题？”

答案是：会！因为每一次 append dou是原子操作，但两次连续调用之间可Neng被别的线程抢走机会，导致拼接顺序错乱。

Ru果你想要一次性完成“完整拼接”，得自己再套个同步块：

synchronized  {
    sb.append.append);
}

.toString 方法里有个叫 toStringCache 的字段，第一次调用会把内部 char 拷贝一份存起来以后再调用直接返回这个快照，不必再复制数组。

这对频繁读取但不常改动内容的场景省了不少时间。

问：写了篇关于 StringBuffer 的博客，却发现百度根本不收录，这是怎么回事？

A：可Neng是因为内容重复度太高，或者缺少独特的视角和关键词密度。咱就是说把标题和段落里自然嵌入 “StringBuffer 用法”“Java 多线程 字符串拼接”等长尾词，多写点案例代码，配上自己的经验感悟，就Neng提升收录概率啦。懂的dou懂，别忘了给页面加上合适的 meta 描述和 alt 文本噢~哈哈！

public class SyncOverheadDemo {
    public static void main {
        int iterations = 100_000;
        // 单线程 StringBuffer
        StringBuffer buffer = new StringBuffer;
        long start = System.nanoTime;
        for  {
            buffer.append;
        }
        long tBuffer = System.nanoTime - start;
        // 单线程 StringBuilder
        StringBuilder builder = new StringBuilder;
        start = System.nanoTime;
        for  {
            builder.append;
        }
        long tBuilder = System.nanoTime - start;
        System.out.printf;
        System.out.printf;
        System.out.printf("StringBuilder 快 %.1f 倍%n",
                 tBuffer / tBuilder);
    }
}

P.S. 在单线程环境下你会kan到 Builder 快几倍，这正说明同步带来的开销不是闹着玩的。

The class is declared as public final class StringBuffer …

*final* 防止子类覆写同步方法，从而破坏原本的线程安全语义。想想要是有人把 append 改成非同步，那还有谁相信它啊！害，我差点忘说这个细节呢~

Synchronized 同样装饰了写对象的方法，以防在序列化期间其他线程改数据导致快照不一致。

# 小技巧 # Ru果你自己实现 Serializable，一定记得给 Buffer 加上自定义 writeObject/readObject，否则也会出现类似“脏数据”。你懂的~

- 不推荐，用 SringBuilder, 少一个锁就省一笔开销；除非你硬要保持 API 一致性，否则没必要搞这么重。哈哈！

- .toString 本身是 synchronized 的，还带缓存，所以读操作也是安全的。不过Ru果读的时候正好有人在写，那读到的是旧数据或者Zui新快照，dou没问题，只是可Neng不是Zui新状态而Yi。

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence {
    private transient char toStringCache;
    public synchronized StringBuffer append {
        toStringCache = null;
        super.append;
        return this;
    }
    // …其余方法同理…
}

# 小结 # 每个公开修改方法dou会先清除缓存，再委托父类完成真正逻辑，然后返回自身，实现链式调用。这种设计kan起来hen朴素，却恰恰保证了「可变」+「安全」两大需求。