// 好的做法
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,          // 核心線程數(shù)
    maximumPoolSize,       // 最大線程數(shù)
    keepAliveTime,         // 線程存活時(shí)間
    TimeUnit.SECONDS,      // 時(shí)間單位
    new LinkedBlockingQueue<>(queueCapacity), // 任務(wù)隊(duì)列
    new ThreadFactoryBuilder().setNameFormat("worker-%d").build(), // 線程工廠
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒絕策略
);

// 不好的做法
ExecutorService executor = Executors.newFixedThreadPool(10); // 可能導(dǎo)致 OOM

@Bean
public ThreadPoolTaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(10);
    executor.setMaxPoolSize(20);
    executor.setQueueCapacity(100);
    executor.setThreadNamePrefix("task-");
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.initialize();
    return executor;
}

// 好的做法
public class Counter {
    private final AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();
    }
    public int getCount() {
        return count.get();
    }
}
// 不好的做法
public class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized int getCount() {
        return count;
    }
}

// 高并發(fā)讀寫(xiě)
private final Map<String, User> userMap = new ConcurrentHashMap<>();
// 讀多寫(xiě)少
private final List<User> userList = new CopyOnWriteArrayList<>();
// 生產(chǎn)者-消費(fèi)者
private final BlockingQueue<Message> messageQueue = new LinkedBlockingQueue<>();

// 最佳實(shí)踐
public enum Singleton {
    INSTANCE;
    private final UserService userService;
    Singleton() {
        userService = new UserService();
    }
    public UserService getUserService() {
        return userService;
    }
}
// 使用
UserService userService = Singleton.INSTANCE.getUserService();

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// 原子更新
AtomicInteger counter = new AtomicInteger(0);
// 遞增
int value = counter.incrementAndGet();
// 比較并交換
boolean updated = counter.compareAndSet(expectedValue, newValue);

// 等待多個(gè)線程完成
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
    executor.submit(() -> {
        try {
            // 執(zhí)行任務(wù)
        } finally {
            latch.countDown();
        }
    });
}
// 等待所有任務(wù)完成
latch.await();

// 等待多個(gè)線程到達(dá)屏障
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有線程已到達(dá)屏障");
});
for (int i = 0; i < 3; i++) {
    executor.submit(() -> {
        try {
            // 執(zhí)行任務(wù)
            barrier.await();
            // 繼續(xù)執(zhí)行
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
}

// 控制并發(fā)訪問(wèn)數(shù)
Semaphore semaphore = new Semaphore(5);
for (int i = 0; i < 10; i++) {
    executor.submit(() -> {
        try {
            semaphore.acquire();
            try {
                // 執(zhí)行任務(wù)
            } finally {
                semaphore.release();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
}

// 異步執(zhí)行
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    // 執(zhí)行任務(wù)
    return "Result 1";
});
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    // 執(zhí)行任務(wù)
    return "Result 2";
});
// 組合結(jié)果
CompletableFuture<String> combined = future1.thenCombine(future2, (result1, result2) -> {
    return result1 + ", " + result2;
});
// 獲取結(jié)果
String result = combined.join();

// 好的做法：按固定順序獲取鎖
public void transferMoney(Account from, Account to, int amount) {
    int fromHash = System.identityHashCode(from);
    int toHash = System.identityHashCode(to);
    if (fromHash < toHash) {
        synchronized (from) {
            synchronized (to) {
                from.debit(amount);
                to.credit(amount);
            }
        }
    } else if (fromHash > toHash) {
        synchronized (to) {
            synchronized (from) {
                from.debit(amount);
                to.credit(amount);
            }
        }
    } else {
        // 使用額外的鎖
        synchronized (lock) {
            synchronized (from) {
                synchronized (to) {
                    from.debit(amount);
                    to.credit(amount);
                }
            }
        }
    }
}

public class InventoryService {
    private final ConcurrentHashMap<String, AtomicInteger> inventory = new ConcurrentHashMap<>();
    public boolean decreaseStock(String productId, int quantity) {
        AtomicInteger stock = inventory.computeIfAbsent(productId, k -> new AtomicInteger(0));
        while (true) {
            int currentStock = stock.get();
            if (currentStock < quantity) {
                return false; // 庫(kù)存不足
            }
            if (stock.compareAndSet(currentStock, currentStock - quantity)) {
                return true; // 成功減少庫(kù)存
            }
            // 競(jìng)爭(zhēng)失敗，重試
        }
    }
    public int getStock(String productId) {
        AtomicInteger stock = inventory.get(productId);
        return stock != null ? stock.get() : 0;
    }
    public void increaseStock(String productId, int quantity) {
        AtomicInteger stock = inventory.computeIfAbsent(productId, k -> new AtomicInteger(0));
        stock.addAndGet(quantity);
    }
}