性能突破的关键--Java 并发编程核心优化

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ProductStock {
    private int stock = 1000; // 商品库存
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();

    // 查询库存（读操作）
    public int getStock() {
        readLock.lock();
        try {
            return stock; // 读操作无互斥，多线程同时执行
        } finally {
            readLock.unlock();
        }
    }

    // 扣减库存（写操作）
    public boolean deductStock(int num) {
        writeLock.lock();
        try {
            if (stock >= num) {
                stock -= num;
                return true;
            }
            return false;
        } finally {
            writeLock.unlock();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class ApiCounter {
    // 无锁计数器，基于 CAS 实现原子递增
    private final AtomicInteger count = new AtomicInteger(0);

    // 接口访问时调用，统计访问量
    public void increment() {
        count.incrementAndGet(); // CAS 原子操作，无阻塞
    }

    // 获取总访问量
    public int getTotalCount() {
        return count.get();
    }
}

// AtomicStampedReference 解决 ABA 问题
AtomicStampedReference<Integer> stampedRef = new AtomicStampedReference<>(100, 0);
int stamp = stampedRef.getStamp(); // 获取当前版本号
// 仅当值为 100 且版本号为 stamp 时，更新为 200，版本号自增
boolean success = stampedRef.compareAndSet(100, 200, stamp, stamp + 1);

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CustomThreadPool {
    // CPU 核心数
    private static final int CPU_CORES = Runtime.getRuntime().availableProcessors();
    // 自定义线程池：IO 密集型，核心线程数=CPU*2，最大线程数=20，队列容量=100
    public static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(
            CPU_CORES * 2,
            20,
            60L,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(100), // 有界队列，避免 OOM
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略：调用者线程执行
    );

    // 关闭线程池（程序退出时调用）
    public static void shutdown() {
        EXECUTOR.shutdown();
        try {
            // 等待 30 秒，若仍有任务未完成则强制关闭
            if (!EXECUTOR.awaitTermination(30, TimeUnit.SECONDS)) {
                EXECUTOR.shutdownNow();
            }
        } catch (InterruptedException e) {
            EXECUTOR.shutdownNow();
        }
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class SeckillQueue {
    // 有界阻塞队列，容量=1000，存储秒杀商品 ID
    private static final BlockingQueue<String> QUEUE = new ArrayBlockingQueue<>(1000);

    // 生产者：添加秒杀商品到队列
    public static boolean addSeckillProduct(String productId) {
        try {
            // 队列满时阻塞，避免 OOM
            QUEUE.put(productId);
            return true;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }

    // 消费者：处理秒杀商品
    public static void processSeckill() {
        CustomThreadPool.EXECUTOR.submit(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    // 队列空时阻塞，避免空轮询
                    String productId = QUEUE.take();
                    System.out.println("处理秒杀商品：" + productId);
                    // 执行秒杀逻辑（如扣减库存、创建订单）
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    }
}

public class UserContext {
    // ThreadLocal 存储当前线程的用户信息
    private static final ThreadLocal<UserInfo> USER_THREAD_LOCAL = new ThreadLocal<>();

    // 设置用户信息到上下文
    public static void setUser(UserInfo userInfo) {
        USER_THREAD_LOCAL.set(userInfo);
    }

    // 获取当前线程的用户信息
    public static UserInfo getUser() {
        return USER_THREAD_LOCAL.get();
    }

    // 移除用户信息，避免内存泄漏和数据污染
    public static void removeUser() {
        USER_THREAD_LOCAL.remove();
    }

    // 用户信息实体类
    public static class UserInfo {
        private String userId;
        private String userName;
        // getter/setter
    }
}

// 线程池任务中使用
CustomThreadPool.EXECUTOR.submit(() -> {
    try {
        // 设置上下文
        UserContext.setUser(new UserContext.UserInfo("1001", "张三"));
        // 执行业务逻辑（如查询用户订单）
        queryUserOrders();
    } finally {
        // 必须移除，避免线程复用导致数据错乱
        UserContext.removeUser();
    }
});

import java.util.concurrent.locks.ReentrantLock;

public class TransferService {
    // 账户锁映射：key=账户ID，value=锁
    private final Map<String, ReentrantLock> accountLocks = new ConcurrentHashMap<>();

    // 初始化账户锁（若不存在则创建）
    private ReentrantLock getAccountLock(String accountId) {
        return accountLocks.computeIfAbsent(accountId, k -> new ReentrantLock());
    }

    // 转账操作：按账户ID从小到大获取锁
    public boolean transfer(String fromAccount, String toAccount, int amount) {
        // 统一锁获取顺序：先获取 ID 较小的账户锁
        String lock1 = fromAccount.compareTo(toAccount) < 0 ? fromAccount : toAccount;
        String lock2 = fromAccount.compareTo(toAccount) > 0 ? fromAccount : toAccount;

        ReentrantLock reentrantLock1 = getAccountLock(lock1);
        ReentrantLock reentrantLock2 = getAccountLock(lock2);

        // 尝试获取锁，超时 3 秒
        try {
            boolean lock1Acquired = reentrantLock1.tryLock(3, TimeUnit.SECONDS);
            if (!lock1Acquired) {
                return false;
            }
            try {
                boolean lock2Acquired = reentrantLock2.tryLock(3, TimeUnit.SECONDS);
                if (!lock2Acquired) {
                    return false;
                }
                try {
                    // 执行转账逻辑（扣减转出账户余额，增加转入账户余额）
                    return doTransfer(fromAccount, toAccount, amount);
                } finally {
                    reentrantLock2.unlock();
                }
            } finally {
                reentrantLock1.unlock();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }

    // 实际转账逻辑（省略）
    private boolean doTransfer(String fromAccount, String toAccount, int amount) {
        // ...
        return true;
    }
}