StringBuffer：线程安全的可变字符串

// 原来的代码：使用 StringBuilder 作为全局日志缓冲
public class Logger {
    private static StringBuilder logBuffer = new StringBuilder();

    public static void log(String msg) {
        logBuffer.append(msg).append("\n");  // 多线程写入！
    }
}
// 启动 100 个线程同时写日志 → 最终长度不足预期（数据丢失）

// StringBuffer.java 源码片段
@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

@Override
public synchronized StringBuffer insert(int offset, String str) {
    toStringCache = null;
    super.insert(offset, str);
    return this;
}

public class StringBufferThreadSafeDemo {
    public static void main(String[] args) throws InterruptedException {
        StringBuffer sharedBuffer = new StringBuffer();  // 线程安全

        // 启动 10 个线程，每个追加 1000 个字符
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            final int id = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    sharedBuffer.append(id % 10);  // synchronized 保证原子性
                }
            });
            threads[i].start();
        }

        for (Thread t : threads) {
            t.join();  // 等待所有线程完成
        }

        System.out.println("最终长度: " + sharedBuffer.length());  // 应该是 10000
        // 如果用 StringBuilder，长度可能 < 10000（数据丢失）
    }
}

public class ThreadSafeLogger {
    // 使用 StringBuffer 作为线程安全的日志缓冲区
    private static final StringBuffer logBuffer = new StringBuffer(8192);

    public static void main(String[] args) throws InterruptedException {
        System.out.println("===== 飞翔科技 多线程日志系统 =====\n");

        // ========== 启动 5 个模拟服务线程 ==========
        Thread[] services = new Thread[5];
        String[] serviceNames = {"订单服务", "支付服务", "库存服务", "用户服务", "通知服务"};

        for (int i = 0; i < 5; i++) {
            final String name = serviceNames[i];
            services[i] = new Thread(() -> {
                for (int j = 0; j < 10; j++) {
                    log("[INFO] " + name + " - 处理第 " + (j + 1) + " 条请求");
                    try {
                        Thread.sleep((long) (Math.random() * 10));  // 模拟处理时间
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }, name);
            services[i].start();
        }

        // ========== 主线程定期输出日志 ==========
        for (int round = 0; round < 3; round++) {
            Thread.sleep(50);  // 等待 50ms 收集一批日志
            flushLogs();
        }

        // ========== 等待所有服务线程结束 ==========
        for (Thread t : services) {
            t.join();
        }
        flushLogs();  // 最后一批

        System.out.println("\n所有服务线程已完成。日志系统关闭。");
    }

    // 线程安全地读取并清空日志
    private static synchronized void flushLogs() {
        if (logBuffer.length() > 0) {
            System.out.println("--- 日志刷新 (" + logBuffer.length() + " 字符) ---");
            System.out.print(logBuffer.toString());
            logBuffer.setLength(0);  // 清空缓冲区（线程安全）
        }
    }

    // 日志写入方法
    private static void log(String message) {
        logBuffer.append(System.currentTimeMillis() % 100000)
                 .append(" [")
                 .append(Thread.currentThread().getName())
                 .append("] ")
                 .append(message)
                 .append("\n");
    }
}

// ⚠️ 看似安全，实际不是！
StringBuffer sb = new StringBuffer();
// 线程 A: sb.append("Hello-");
// 线程 B: sb.append("World-");
// 可能出现: "Hello-World-" ✓（A 先完成，B 后完成）
//       或: "World-Hello-" ✓（B 先完成，A 后完成）
// 不会出现: "HeWlloor-ld-" ✗（单次 append 是原子的，字符不会交错）

// ❌ 使用 StringBuilder 时，单次 append 也可能交错
StringBuilder sb2 = new StringBuilder();
// 线程 A: sb2.append("Hello-");
// 线程 B: sb2.append("World-");
// 可能出现: "HeWlloor-ld-"（字符交错！因为 count 和 value 的修改被打断）

// ⚠️ 即使是 StringBuffer，这两行之间也可能被其他线程插入
sb.append(userName);
sb.append(" - ");  // 另一个线程可能在这两行之间 append 了内容

// ❌ 错误：多线程共享 StringBuilder 导致数据混乱
public class Logger {
    private static StringBuilder log = new StringBuilder();  // 单例，多线程共享！

    public static void info(String msg) {
        log.append("[INFO] ").append(msg).append("\n");  // 线程不安全！
    }
}

// ✅ 正确一：改用 StringBuffer
public class Logger {
    private static StringBuffer log = new StringBuffer();

    public static void info(String msg) {
        log.append("[INFO] ").append(msg).append("\n");  // 单次 append 线程安全
    }
}

// ✅ 正确二：局部变量使用 StringBuilder（推荐，线程封闭）
public class Logger {
    public static void info(String msg) {
        StringBuilder sb = new StringBuilder();  // 局部变量，线程封闭
        sb.append("[INFO] ").append(msg);
        System.out.println(sb.toString());
    }
}

// ❌ 错误：复合操作不加外部同步
private static StringBuffer report = new StringBuffer();
public static void addSection(String title, String body) {
    report.append("=== ").append(title).append(" ===\n");
    report.append(body).append("\n\n");  // 这两次 append 之间可能被打断！
}

// ✅ 正确：复合操作用外部 synchronized 保护
private static StringBuffer report = new StringBuffer();
public static synchronized void addSection(String title, String body) {
    report.append("=== ").append(title).append(" ===\n");
    report.append(body).append("\n\n");
}