并发编程多线程同步实战：工具选型、原理与避坑技巧

// 计数器类（非线程安全）
public class Counter {
    private int count = 0;
    // 非原子操作：读count→加1→写回count
    public void increment() { count++; }
    public int getCount() { return count; }
}

// 测试代码
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter.increment();
        });
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println(counter.getCount()); // 结果常小于20000
    }
}

public class Singleton {
    private static Singleton instance;
    private Singleton() {} // 私有构造
    // 同步getInstance方法，避免多线程创建多个实例
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class SafeCounter {
    private int count = 0;
    // 可重入锁，默认非公平
    private final Lock lock = new ReentrantLock();
    public void increment() {
        lock.lock(); // 显式加锁
        try {
            count++; // 临界区操作
        } finally {
            lock.unlock(); // 必须在finally释放锁，避免死锁
        }
    }
    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

public class DBConnectionPool {
    private final Semaphore semaphore = new Semaphore(10);
    private final List<Connection> connections = new ArrayList<>();

    public DBConnectionPool() {
        // 初始化10个数据库连接
        for (int i = 0; i < 10; i++) {
            connections.add(createConnection());
        }
    }

    public Connection getConnection() throws InterruptedException {
        semaphore.acquire(); // 获取许可（最多10个线程同时获取）
        return connections.remove(0);
    }

    public void releaseConnection(Connection conn) {
        connections.add(conn);
        semaphore.release(); // 归还许可
    }
}

public class ResourceLoader {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        // 启动3个子线程加载资源
        new Thread(() -> { loadImage(); latch.countDown(); }).start();
        new Thread(() -> { loadConfig(); latch.countDown(); }).start();
        new Thread(() -> { loadData(); latch.countDown(); }).start();
        latch.await(); // 主线程等待，直到所有资源加载完成
        System.out.println("所有资源加载完成，启动应用");
    }
}

public class ParallelCalculator {
    public static void main(String[] args) {
        // 4个线程到达后，执行“合并结果”的回调
        CyclicBarrier barrier = new CyclicBarrier(4, () -> {
            System.out.println("所有线程计算完成，合并结果");
        });
        // 启动4个线程执行计算
        for (int i = 0; i < 4; i++) {
            new Thread(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "开始计算");
                    Thread.sleep(1000); // 模拟计算
                    System.out.println(Thread.currentThread().getName() + "到达屏障");
                    barrier.await(); // 等待其他线程
                    System.out.println(Thread.currentThread().getName() + "继续执行");
                } catch (Exception e) { e.printStackTrace(); }
            }).start();
        }
    }
}

// 错误写法：同步整个方法（包含非临界区）
public synchronized void updateUser() {
    log.info("开始更新用户"); // 非临界区（不需要同步）
    userDao.update(user); // 临界区（需要同步）
    log.info("更新完成"); // 非临界区
}

// 正确写法：同步临界区代码块
public void updateUser() {
    log.info("开始更新用户");
    synchronized (this) {
        userDao.update(user); // 只同步需要保护的部分
    }
    log.info("更新完成");
}

// 线程1：先锁A再锁B
synchronized (lockA) {
    synchronized (lockB) { ... }
}

// 线程2：先锁B再锁A（循环等待，导致死锁）
synchronized (lockB) {
    synchronized (lockA) { ... }
}

public class VolatileTest {
    private volatile int count = 0;
    // 错误：count++不是原子操作（读-改-写）
    public void increment() { count++; }
}