生产级最佳实践：Java并发编程完整指南

// 1. 线程安全的优先级
// 正确性 > 性能 > 可读性

// ❌ 错误：追求性能，忽略安全
public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++;  // 非原子操作，线程不安全
    }
}

// ✅ 正确：优先保证线程安全
public class SafeCounter {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();  // 原子操作，线程安全
    }
}

// ❌ 错误：同步范围过大
public synchronized void process() {
    prepareData();       // 无需同步
    accessSharedData();  // 需要同步
    cleanup();           // 无需同步
}

// ✅ 正确：最小化同步范围
public void process() {
    prepareData();

    synchronized (lock) {
        accessSharedData();  // 只同步必要代码
    }

    cleanup();
}

// ❌ 复杂：使用锁保护可变对象
public class MutablePoint {
    private int x, y;

    public synchronized void setX(int x) {
        this.x = x;
    }

    public synchronized int getX() {
        return x;
    }
}

// ✅ 简单：使用不变对象
public final class ImmutablePoint {
    private final int x, y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;  // 无需同步
    }
}

// ❌ 错误：直接创建线程
for (int i = 0; i < 10000; i++) {
    new Thread(() -> task()).start();  // 线程数爆炸
}

// ✅ 正确：使用线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10, 20,  // 核心线程数、最大线程数
    60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000),
    new ThreadFactoryBuilder()
        .setNameFormat("business-pool-%d")
        .build(),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

for (int i = 0; i < 10000; i++) {
    executor.submit(() -> task());
}

// CPU密集型任务
int cpuCount = Runtime.getRuntime().availableProcessors();
int corePoolSize = cpuCount + 1;

// I/O密集型任务
int corePoolSize = cpuCount * 2;

// 混合型任务（推荐公式）
// corePoolSize = N * (1 + WT/ST)
// N = CPU核心数
// WT = 等待时间
// ST = 计算时间
int corePoolSize = cpuCount * (1 + waitTime / computeTime);

// 队列容量
int queueCapacity = peakQPS * avgExecutionTime;

// 最大线程数
int maximumPoolSize = corePoolSize * 2;

// ✅ 使用ThreadFactory自定义线程名
ThreadFactory threadFactory = new ThreadFactoryBuilder()
    .setNameFormat("business-pool-%d")
    .setDaemon(false)
    .setPriority(Thread.NORM_PRIORITY)
    .setUncaughtExceptionHandler((t, e) -> {
        log.error("线程异常：" + t.getName(), e);
    })
    .build();

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10, 20, 60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000),
    threadFactory,
    new ThreadPoolExecutor.CallerRunsPolicy()
);

// 1. 读多写少：StampedLock
StampedLock sl = new StampedLock();
long stamp = sl.tryOptimisticRead();
// 读取数据
if (!sl.validate(stamp)) {
    stamp = sl.readLock();
    try {
        // 重新读取
    } finally {
        sl.unlockRead(stamp);
    }
}

// 2. 公平性要求：ReentrantLock(true)
Lock lock = new ReentrantLock(true);

// 3. 简单场景：synchronized
synchronized (lock) {
    // 业务逻辑
}

// 4. 高并发计数：LongAdder
LongAdder counter = new LongAdder();
counter.increment();

// ❌ 粗粒度锁：性能差
public synchronized void process(String key, String value) {
    map.put(key, value);  // 所有key共用一个锁
}

// ✅ 细粒度锁：性能好
private final ConcurrentHashMap<String, Lock> lockMap = new ConcurrentHashMap<>();

public void process(String key, String value) {
    Lock lock = lockMap.computeIfAbsent(key, k -> new ReentrantLock());
    lock.lock();
    try {
        map.put(key, value);  // 每个key独立锁
    } finally {
        lock.unlock();
    }
}

// ✅ 固定加锁顺序
public void transfer(Account from, Account to, int amount) {
    Account first, second;

    if (from.getId() < to.getId()) {
        first = from;
        second = to;
    } else {
        first = to;
        second = from;
    }

    synchronized (first) {
        synchronized (second) {
            // 转账逻辑
        }
    }
}

// ✅ 使用tryLock超时
if (lock1.tryLock(1, TimeUnit.SECONDS)) {
    try {
        if (lock2.tryLock(1, TimeUnit.SECONDS)) {
            try {
                // 业务逻辑
            } finally {
                lock2.unlock();
            }
        }
    } finally {
        lock1.unlock();
    }
}

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// ❌ 错误：组合操作不原子
if (!map.containsKey(key)) {
    map.put(key, value);  // 线程不安全
}

// ✅ 正确：使用原子方法
map.putIfAbsent(key, value);

// ✅ 原子更新
map.compute(key, (k, v) -> (v == null ? 0 : v) + 1);

// ✅ 原子替换
map.replace(key, oldValue, newValue);

// ✅ 务必指定线程池
ExecutorService executor = Executors.newFixedThreadPool(10);

CompletableFuture.supplyAsync(() -> {
    return queryData();
}, executor)  // 指定线程池
.thenApplyAsync(data -> {
    return processData(data);
}, executor)
.exceptionally(ex -> {
    log.error("异步任务失败", ex);
    return defaultValue;
})
.thenAccept(result -> {
    log.info("结果：{}", result);
});

// ✅ 并行查询
CompletableFuture<UserInfo> userFuture = CompletableFuture.supplyAsync(() -> queryUser(), executor);
CompletableFuture<List<Order>> orderFuture = CompletableFuture.supplyAsync(() -> queryOrders(), executor);

CompletableFuture.allOf(userFuture, orderFuture)
    .thenApply(v -> {
        UserInfo user = userFuture.join();
        List<Order> orders = orderFuture.join();
        return new UserDetailDTO(user, orders);
    });

// ✅ 设置超时
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return slowQuery();
}, executor);

try {
    String result = future.get(1, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    log.error("查询超时");
    return defaultValue;
}

// ✅ Java 9+：orTimeout
future.orTimeout(1, TimeUnit.SECONDS)
      .exceptionally(ex -> defaultValue);

# 通用配置
-Xms4g -Xmx4g              # 堆内存
-Xss1m                      # 线程栈
-XX:+UseG1GC                # 使用G1垃圾回收器
-XX:MaxGCPauseMillis=200    # GC暂停时间目标
-XX:ParallelGCThreads=8     # 并行GC线程数
-XX:ConcGCThreads=2         # 并发GC线程数

# 偏向锁（低竞争场景）
-XX:+UseBiasedLocking
-XX:BiasedLockingStartupDelay=0

# 容器环境
-XX:ActiveProcessorCount=2  # 显式指定CPU核心数
-Djava.util.concurrent.ForkJoinPool.common.parallelism=2

# 监控与调试
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/heapdump.hprof
-Xloggc:/var/log/gc.log
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps

# application.yml
server:
  tomcat:
    threads:
      max: 200          # 最大线程数
      min-spare: 10     # 最小空闲线程数
    accept-count: 100   # 等待队列长度
    max-connections: 10000  # 最大连接数

spring:
  task:
    execution:
      pool:
        core-size: 10
        max-size: 20
        queue-capacity: 1000
        thread-name-prefix: async-pool-

// 1. 线程池监控
public class ThreadPoolMonitor {
    @Scheduled(fixedRate = 5000)
    public void monitor() {
        // 活跃线程数
        int activeCount = executor.getActiveCount();

        // 队列大小
        int queueSize = executor.getQueue().size();

        // 线程利用率
        double threadUtilization = (double) activeCount / executor.getPoolSize() * 100;

        // 队列使用率
        double queueUtilization = (double) queueSize / queueCapacity * 100;

        // 告警
        if (threadUtilization > 90) {
            alert("线程池利用率过高：" + threadUtilization + "%");
        }

        if (queueUtilization > 80) {
            alert("队列积压严重：" + queueUtilization + "%");
        }
    }
}

// 使用Micrometer导出指标
MeterRegistry registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);

// 监控线程池
ExecutorServiceMetrics.monitor(registry, executor, "business-pool", "app", "my-app");

// 访问指标
// http://localhost:8080/actuator/prometheus

1. top -Hp <pid>          # 找到CPU高的线程ID
2. printf "%x\n" <tid>    # 转换为16进制
3. jstack <pid> | grep "0x<hex-id>"  # 查看堆栈
4. 定位代码 → 修复问题

1. jstack <pid> | grep "Found one Java-level deadlock"
2. 分析等待链
3. 修复锁顺序

1. jstack <pid> | wc -l   # 查看线程数
2. jmap -dump:file=heap.hprof <pid>
3. MAT分析Thread对象
4. 定位泄漏点