// 暴露线程池指标
@Component
public class ThreadPoolMetrics {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;
    
    @PostConstruct
    public void init() {
        // 活跃线程数
        Gauge.builder("threadpool.active.count", 
                      threadPoolExecutor::getActiveCount)
             .register(meterRegistry);
        
        // 队列长度
        Gauge.builder("threadpool.queue.size", 
                      () -> threadPoolExecutor.getQueue().size())
             .register(meterRegistry);
        
        // 拒绝任务数
        Gauge.builder("threadpool.rejected.count", 
                      () -> ((ThreadPoolExecutor.Statistics) threadPoolExecutor).getRejectedCount())
             .register(meterRegistry);
    }
}

// ❌ 错误：循环内创建大量临时对象
for (int i = 0; i < 10000; i++) {
    String key = "prefix_" + i;  // 每次循环创建新字符串
    Map<String, Object> map = new HashMap<>();  // 每次循环创建新 Map
    map.put(key, value);
}

// ✅ 正确：复用对象
Map<String, Object> map = new HashMap<>(10000);  // 预分配容量
for (int i = 0; i < 10000; i++) {
    String key = "prefix_" + i;
    map.put(key, value);
}

// ❌ 错误：回溯爆炸
String regex = "(a+)+b";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher("aaaaaaaaaaaaaaaaX");
matcher.matches();  // 可能耗时极长

// ✅ 正确：优化正则
String regex = "a+b";
Pattern pattern = Pattern.compile(regex);

// ❌ 错误：同步 HTTP 调用
public Response callExternalService(Request request) {
    return httpClient.execute(request);  // 阻塞等待
}

// ✅ 正确：异步调用
public CompletableFuture<Response> callExternalService(Request request) {
    return httpClient.executeAsync(request);  // 异步非阻塞
}

// ❌ 错误：频繁创建临时对象
public String buildMessage(User user) {
    StringBuilder sb = new StringBuilder();
    sb.append("Hello, ");
    sb.append(user.getName());
    sb.append("! Your age is ");
    sb.append(user.getAge());
    sb.append(".");
    return sb.toString();
}

// ✅ 正确：使用 String.format 或文本块
public String buildMessage(User user) {
    return String.format("Hello, %s! Your age is %d.", 
                         user.getName(), user.getAge());
}

// ✅ 更好：JDK 15+ 文本块
public String buildMessage(User user) {
    return """
        Hello, %s! Your age is %d.
        """.formatted(user.getName(), user.getAge());
}

// ❌ 错误：循环内创建对象
List<Result> results = new ArrayList<>();
for (Data data : dataList) {
    Result result = new Result();  // 每次循环创建新对象
    result.setId(data.getId());
    result.setName(data.getName());
    results.add(result);
}

// ✅ 正确：使用 Stream + Map
List<Result> results = dataList.stream()
    .map(data -> new Result(data.getId(), data.getName()))
    .collect(Collectors.toList());

// ✅ 更好：对象池（高频场景）
private static final ObjectPool<Result> resultPool = 
    new GenericObjectPool<>(new ResultFactory());

List<Result> results = dataList.stream()
    .map(data -> {
        Result result = resultPool.borrowObject();
        result.setId(data.getId());
        result.setName(data.getName());
        return result;
    })
    .collect(Collectors.toList());

// 使用后归还
results.forEach(resultPool::returnObject);

// ✅ 适合使用对象池：数据库连接
HikariDataSource dataSource = new HikariDataSource(config);

// ❌ 不适合使用对象池：普通 DTO
// 直接 new 即可，JVM 逃逸分析会优化
DTO dto = new DTO();
dto.setId(1);
dto.setName("test");

// ✅ 使用 Caffeine 本地缓存
private static final Cache<String, Product> productCache = Caffeine.newBuilder()
    .maximumSize(10_000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build();

public Product getProduct(Long id) {
    return productCache.get(id.toString(), key -> 
        productRepository.findById(Long.parseLong(key))
    );
}

// ✅ 使用 Redis 分布式缓存
@Autowired
private RedisTemplate<String, Product> redisTemplate;

public Product getProduct(Long id) {
    String key = "product:" + id;
    Product product = redisTemplate.opsForValue().get(key);
    
    if (product == null) {
        product = productRepository.findById(id);
        redisTemplate.opsForValue().set(key, product, 10, TimeUnit.MINUTES);
    }
    
    return product;
}

// ✅ 异步发送邮件
@Autowired
private AsyncTaskExecutor taskExecutor;

public void registerUser(User user) {
    userRepository.save(user);
    
    // 异步发送欢迎邮件
    taskExecutor.execute(() -> {
        emailService.sendWelcomeEmail(user.getEmail());
    });
}

// ✅ 异步报表导出
@PostMapping("/export")
public String exportReport(@RequestParam String queryId) {
    CompletableFuture.runAsync(() -> {
        // 后台生成报表
        Report report = reportGenerator.generate(queryId);
        
        // 通知用户下载
        notificationService.sendDownloadLink(queryId, report.getFileUrl());
    });
    
    return "导出任务已提交，完成后将通知您";
}

// ✅ Sentinel 限流
@SentinelResource(value = "queryProduct", 
                  blockHandler = "handleBlock")
public Product queryProduct(Long id) {
    return productService.getProduct(id);
}

public Product handleBlock(Long id, BlockException ex) {
    log.warn("请求被限流: {}", id);
    return getDefaultProduct();  // 返回默认值
}

// ✅ Guava RateLimiter
private static final RateLimiter rateLimiter = RateLimiter.create(1000);  // 1000 QPS

public Product queryProduct(Long id) {
    if (!rateLimiter.tryAcquire(1, TimeUnit.SECONDS)) {
        throw new ServiceException("请求过于频繁，请稍后重试");
    }
    return productService.getProduct(id);
}