并发设计模式与最佳实践

/**
 * 标准的不可变对象设计
 */
public final class ImmutableUser {
    private final String name;
    private final int age;
    private final List<String> hobbies;

    public ImmutableUser(String name, int age, List<String> hobbies) {
        this.name = name;
        this.age = age;
        // 防御性复制
        this.hobbies = new ArrayList<>(hobbies);
    }

    public String getName() { return name; }
    public int getAge() { return age; }

    public List<String> getHobbies() {
        // 返回不可变视图
        return Collections.unmodifiableList(hobbies);
    }
}

/*
不可变对象的五大要求：
1. ✅ 类声明为final
2. ✅ 所有字段都是final
3. ✅ 所有字段都是private
4. ✅ 不提供setter方法
5. ✅ 可变字段防御性复制

优势：
├─ 天然线程安全
├─ 可以安全共享
└─ 适合做缓存key

适用场景：String、Integer、LocalDate等
*/

/**
 * ThreadLocal：线程本地存储
 */
public class ThreadLocalExample {
    // 每个线程独立的SimpleDateFormat
    private static ThreadLocal<SimpleDateFormat> dateFormat =
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));

    public static String formatDate(Date date) {
        return dateFormat.get().format(date);  // 线程安全
    }

    public static void main(String[] args) {
        // 10个线程并发格式化日期
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.out.println(formatDate(new Date()));
            }).start();
        }
    }
}

/*
使用场景：
1. SimpleDateFormat（线程不安全）
2. 数据库连接（每个线程独立连接）
3. 用户上下文（Spring Security）
*/

/**
 * ThreadLocal内存泄漏问题
 */
public class ThreadLocalMemoryLeak {
    private static ThreadLocal<byte[]> threadLocal = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        // 线程池场景
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 100; i++) {
            executor.submit(() -> {
                // 存储大对象
                threadLocal.set(new byte[1024 * 1024]);  // 1MB

                // 业务逻辑
                // ...

                // ❌ 忘记清理，导致内存泄漏
                // threadLocal.remove();  // 正确做法
            });
        }

        executor.shutdown();
    }

    /*
    内存泄漏原因：
    1. ThreadLocal存储在ThreadLocalMap中
    2. key是弱引用（ThreadLocal）
    3. value是强引用（实际对象）
    4. 线程池线程复用，ThreadLocalMap一直存在
    5. value无法被GC，导致内存泄漏

    解决方案：
    try {
        threadLocal.set(value);
        // 业务逻辑
    } finally {
        threadLocal.remove();  // 必须清理
    }
    */
}

/**
 * 正确的线程停止方式
 */
public class GracefulShutdown {
    private volatile boolean running = true;

    public void start() {
        Thread thread = new Thread(() -> {
            while (running) {  // 检查标志位
                try {
                    // 业务逻辑
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // 响应中断
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            // 清理资源
            cleanup();
        });
        thread.start();
    }

    public void stop() {
        running = false;  // 第一阶段：设置标志位
    }

    private void cleanup() {
        // 第二阶段：清理资源
        System.out.println("清理资源");
    }

    /*
    错误做法：
    thread.stop();  // ❌ 已废弃，不安全

    正确做法：
    1. volatile标志位
    2. interrupt()中断
    3. 两阶段：设置标志 + 清理资源
    */
}

/**
 * 读写锁：读多写少场景
 */
public class ReadWriteLockExample {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Map<String, String> cache = new HashMap<>();

    // 读操作：共享锁
    public String get(String key) {
        rwLock.readLock().lock();
        try {
            return cache.get(key);
        } finally {
            rwLock.readLock().unlock();
        }
    }

    // 写操作：排他锁
    public void put(String key, String value) {
        rwLock.writeLock().lock();
        try {
            cache.put(key, value);
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    /*
    读写锁特性：
    ├─ 读-读：可并发
    ├─ 读-写：互斥
    └─ 写-写：互斥

    性能提升：
    读多写少场景，性能比synchronized高3-5倍
    */
}

/**
 * StampedLock：性能更好的读写锁
 */
public class StampedLockExample {
    private final StampedLock lock = new StampedLock();
    private double x, y;

    // 乐观读
    public double distanceFromOrigin() {
        long stamp = lock.tryOptimisticRead();  // 乐观读
        double currentX = x;
        double currentY = y;

        if (!lock.validate(stamp)) {  // 验证是否被修改
            stamp = lock.readLock();  // 升级为悲观读锁
            try {
                currentX = x;
                currentY = y;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    // 写锁
    public void move(double deltaX, double deltaY) {
        long stamp = lock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    /*
    StampedLock优势：
    1. 乐观读不加锁（性能极高）
    2. 读写性能比ReentrantReadWriteLock高
    3. 适合读多写少场景

    注意：
    ❌ 不支持重入
    ❌ 不支持Condition
    */
}

/**
 * 常见并发陷阱
 */
public class ConcurrencyTraps {
    // ❌ 陷阱1：双重检查锁定错误
    private static Singleton instance;
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();  // 需要volatile
                }
            }
        }
        return instance;
    }
    // ✅ 正确：private static volatile Singleton instance;

    // ❌ 陷阱2：SimpleDateFormat共享
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    // ✅ 正确：使用ThreadLocal或DateTimeFormatter

    // ❌ 陷阱3：复合操作不原子
    if (!map.containsKey(key)) {
        map.put(key, value);
    }
    // ✅ 正确：map.putIfAbsent(key, value);

    // ❌ 陷阱4：忘记释放锁
    lock.lock();
    // 业务逻辑
    lock.unlock();  // 异常时不会执行
    // ✅ 正确：try-finally

    // ❌ 陷阱5：使用Executors工厂方法
    Executors.newFixedThreadPool(10);  // 无界队列
    // ✅ 正确：自定义ThreadPoolExecutor

    static class Singleton {
        private static volatile Singleton instance;
        public static Singleton getInstance() { return instance; }
    }
}