在Java中如何使用StringBuffer处理多线程字符串

在Java的字符串操作场景中，String类是不可变的，每次修改都会生成新的对象，频繁修改时会产生大量内存开销。而StringBuffer是线程安全的可变字符序列，专门用于处理多线程场景下的字符串拼接、修改等需求，能够在保证线程安全的同时提升字符串操作的效率。

StringBuffer的线程安全特性

StringBuffer的所有公开方法几乎都使用了synchronized关键字修饰，这意味着多个线程同时调用StringBuffer的同一个实例的方法时，会被串行执行，不会出现数据不一致的问题。相比之下，StringBuilder没有加同步锁，性能更高但只适合单线程场景，多线程下使用会出现线程安全问题。

StringBuffer的基本使用

首先我们需要了解StringBuffer的常用构造方法和基础操作，以下是基础的初始化和字符串拼接示例：

public class StringBufferBasicDemo {
    public static void main(String[] args) {
        // 无参构造，初始容量为16
        StringBuffer sb1 = new StringBuffer();
        // 带初始字符串的构造
        StringBuffer sb2 = new StringBuffer("初始内容");
        // 带初始容量的构造
        StringBuffer sb3 = new StringBuffer(32);

        // 拼接字符串
        sb2.append("，追加内容");
        // 拼接整数
        sb2.append(123);
        // 拼接布尔值
        sb2.append(true);
        System.out.println(sb2.toString()); // 输出：初始内容，追加内容123true

        // 插入内容，在索引5的位置插入字符串
        sb2.insert(5, "插入的");
        System.out.println(sb2.toString()); // 输出：初始内容插入的，追加内容123true

        // 删除指定范围的内容，删除索引5到索引8的内容
        sb2.delete(5, 8);
        System.out.println(sb2.toString()); // 输出：初始内容，追加内容123true

        // 反转字符串
        sb2.reverse();
        System.out.println(sb2.toString()); // 输出：eurt321容内追加，容内始初
    }
}

上面的代码展示了StringBuffer的初始化、追加、插入、删除、反转等基础操作，所有操作都是直接修改内部字符数组，不会生成新的字符串对象，避免了不必要的内存开销。

多线程场景下的StringBuffer使用

在多线程场景中，多个线程同时操作同一个StringBuffer实例时，不用额外加锁就能保证操作的线程安全，以下是一个模拟多线程拼接字符串的示例：

public class StringBufferMultiThreadDemo {
    // 共享的StringBuffer实例
    private static StringBuffer sharedSb = new StringBuffer();

    static class AppendTask implements Runnable {
        private String content;

        public AppendTask(String content) {
            this.content = content;
        }

        @Override
        public void run() {
            // 多个线程同时调用append方法，由于StringBuffer的append方法加了synchronized，不会出现数据错乱
            for (int i = 0; i < 5; i++) {
                sharedSb.append(content).append(i).append(";");
                // 模拟线程执行耗时
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建两个线程，分别追加不同的内容
        Thread thread1 = new Thread(new AppendTask("线程1-"));
        Thread thread2 = new Thread(new AppendTask("线程2-"));

        thread1.start();
        thread2.start();

        // 等待两个线程执行完成
        thread1.join();
        thread2.join();

        System.out.println("最终拼接结果：" + sharedSb.toString());
        // 输出结果中不会混杂错乱的字符，每个线程的追加内容都是完整的
    }
}

在这个示例中，两个线程同时操作同一个sharedSb实例，append方法被synchronized修饰，同一时间只有一个线程能执行append操作，因此最终拼接的字符串内容是完整有序的，不会出现字符交叉错乱的问题。

StringBuffer的注意事项

• 如果确定当前场景是单线程，优先使用StringBuilder，避免StringBuffer的同步锁带来的性能开销。
• StringBuffer的初始容量如果预估不足，会触发内部字符数组的扩容，扩容操作需要复制原有数组，频繁扩容会影响性能，所以如果知道大概的字符串长度，建议初始化时指定合适的容量。
• StringBuffer的toString()方法会返回一个新的String对象，这个对象是线程安全的，因为String本身是不可变的。
• 不要将StringBuffer和String混用，比如频繁用String拼接后再传入StringBuffer，这样会失去StringBuffer的性能优势。

总结

StringBuffer是Java中专门为多线程字符串操作设计的类，通过内置的同步机制保证了线程安全，同时可变字符序列的特性避免了String频繁修改的内存开销。在实际开发中，只要明确是多线程场景下的字符串修改、拼接需求，就可以优先考虑使用StringBuffer，使用时注意合理设置初始容量，避免不必要的性能损耗。

StringBuffer多线程线程安全字符串拼接synchronized修改时间：2026-05-24 13:23:53