深入探讨Java应用性能监控与调优的工具链构建

// 内存泄漏示例
public class CacheManager {
    // 使用静态HashMap可能导致内存泄漏
    private static final Map<String, Object> cache = new HashMap<>();
    
    public static void addToCache(String key, Object value) {
        cache.put(key, value);  // 对象被永久引用，无法被GC回收
    }
    
    // 缺少清理机制
}

// CPU密集型操作示例
public class PrimeCalculator {
    public static List<Integer> findPrimes(int max) {
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= max; i++) {
            boolean isPrime = true;
            for (int j = 2; j < i; j++) {  // 低效算法
                if (i % j == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                primes.add(i);
            }
        }
        return primes;
    }
}

# docker-compose.yml示例
version: '3.6'
services:
  pinpoint-hbase:
    container_name: pinpoint-hbase
    image: pinpointdocker/pinpoint-hbase:2.3.3
    restart: always
    ports:
      - "2181:2181"
      - "16010:16010"
    environment:
      - JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
      - HBASE_MANAGES_ZK=true
    volumes:
      - /path/to/hbase-data:/home/pinpoint/hbase

  pinpoint-collector:
    container_name: pinpoint-collector
    image: pinpointdocker/pinpoint-collector:2.3.3
    restart: always
    ports:
      - "9994:9994"
      - "9995:9995"
      - "9996:9996"
    environment:
      - HBASE_HOST=pinpoint-hbase
      - HBASE_PORT=2181
      - DEBUG_LEVEL=INFO

​​​​​​​  pinpoint-web:
    container_name: pinpoint-web
    image: pinpointdocker/pinpoint-web:2.3.3
    restart: always
    ports:
      - "8080:8080"
    environment:
      - HBASE_HOST=pinpoint-hbase
      - HBASE_PORT=2181
      - DEBUG_LEVEL=INFO

# 添加Pinpoint Agent到Java启动参数
java -javaagent:/path/to/pinpoint-agent/pinpoint-bootstrap-2.3.3.jar \
     -Dpinpoint.agentId=my-application \
     -Dpinpoint.applicationName=MyApplication \
     -jar my-application.jar

# 添加SkyWalking Agent到Java启动参数
java -javaagent:/path/to/skywalking-agent/skywalking-agent.jar \
     -Dskywalking.agent.service_name=my-service \
     -Dskywalking.collector.backend_service=oap-server:11800 \
     -jar my-application.jar

// 可能导致性能问题的数据库操作
@Service
public class ProductService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    public List<Product> findProductsByCategory(String category) {
        // 未优化的SQL查询，可能导致全表扫描
        String sql = "SELECT * FROM products WHERE category LIKE '%" + category + "%'";
        return jdbcTemplate.query(sql, new ProductRowMapper());
    }
}

<!-- Maven依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

# application.properties
# 启用Prometheus端点
management.endpoints.web.exposure.include=prometheus,health,info
# 启用所有指标
management.metrics.enable.all=true

@RestController
public class OrderController {
    private final Counter orderCounter;
    private final Timer orderProcessingTimer;
    
    public OrderController(MeterRegistry registry) {
        this.orderCounter = Counter.builder("app.orders.total")
                .description("Total number of orders processed")
                .register(registry);
                
        this.orderProcessingTimer = Timer.builder("app.orders.processing.time")
                .description("Order processing time")
                .register(registry);
    }
    
    @PostMapping("/orders")
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        return orderProcessingTimer.record(() -> {
            // 处理订单逻辑
            orderCounter.increment();
            return ResponseEntity.ok(orderService.createOrder(order));
        });
    }
}

# prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'spring-boot-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['app-server:8080']

# 堆内存使用率
sum(jvm_memory_used_bytes{area="heap"}) / sum(jvm_memory_max_bytes{area="heap"})

# GC暂停时间
rate(jvm_gc_pause_seconds_sum[5m])

# 线程数
jvm_threads_live_threads

# Prometheus告警规则
groups:
- name: jvm-alerts
  rules:
  - alert: HighHeapUsage
    expr: sum(jvm_memory_used_bytes{area="heap"}) / sum(jvm_memory_max_bytes{area="heap"}) > 0.9
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High Heap Memory Usage"
      description: "JVM heap usage is above 90% for 5 minutes on {{ $labels.instance }}"
      
  - alert: HighGCPauseTime
    expr: rate(jvm_gc_pause_seconds_sum[5m]) > 0.5
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "High GC Pause Time"
      description: "GC pause time is too high on {{ $labels.instance }}"
      
  - alert: HighCPUUsage
    expr: process_cpu_usage > 0.8
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High CPU Usage"
      description: "CPU usage is above 80% for 5 minutes on {{ $labels.instance }}"

-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:InitiatingHeapOccupancyPercent=45

-XX:+UnlockExperimentalVMOptions
-XX:+UseZGC
-XX:ZCollectionInterval=120

java -server \
     -Xms2g -Xmx2g \
     -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=100 \
     -XX:+ParallelRefProcEnabled \
     -XX:ErrorFile=/var/log/java_error.log \
     -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/var/log/java_heapdump.hprof \
     -Xlog:gc*:file=/var/log/gc.log:time,uptime,level,tags:filecount=5,filesize=100m \
     -jar my-application.jar

// 优化前
List<Customer> customers = new ArrayList<>();  // 默认容量为10

// 优化后
List<Customer> customers = new ArrayList<>(10000);  // 预设合适的容量

// 优化前
Map<String, Object> cache = new HashMap<>();  // 负载因子0.75，容量16

// 优化后
Map<String, Object> cache = new HashMap<>(1024, 0.9f);  // 更大的容量和负载因子

// 优化前：创建无限制的线程
ExecutorService executor = Executors.newCachedThreadPool();

// 优化后：创建有界线程池
ExecutorService executor = new ThreadPoolExecutor(
    10,                 // 核心线程数
    20,                 // 最大线程数
    60, TimeUnit.SECONDS, // 空闲线程存活时间
    new ArrayBlockingQueue<>(500), // 工作队列
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

// 优化前：粗粒度锁
public synchronized void updateStats(String key, int value) {
    // 更新统计信息
}

// 优化后：细粒度锁
private final Map<String, Object> lockMap = new ConcurrentHashMap<>();

public void updateStats(String key, int value) {
    Object lock = lockMap.computeIfAbsent(key, k -> new Object());
    synchronized(lock) {
        // 更新特定key的统计信息
    }
}

// 使用Guava缓存
LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .recordStats()
    .build(
        new CacheLoader<Key, Graph>() {
            public Graph load(Key key) throws Exception {
                return createExpensiveGraph(key);
            }
        });

// 优化前：每次调用都创建新对象
public String formatDate(Date date) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    return sdf.format(date);
}

// 优化后：使用ThreadLocal避免重复创建
private static final ThreadLocal<SimpleDateFormat> dateFormatter = 
    ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
    
public String formatDate(Date date) {
    return dateFormatter.get().format(date);
}

# 连接池大小配置
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5

# 连接超时配置
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000

@Bean
public HikariDataSource dataSource() {
    HikariConfig config = new HikariConfig();
    // 基本配置
    config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
    config.setUsername("user");
    config.setPassword("password");
    
    // 连接池配置
    config.setMaximumPoolSize(10);
    config.setMinimumIdle(5);
    
    // 添加指标收集
    config.setMetricRegistry(metricRegistry);
    
    return new HikariDataSource(config);
}

-- 优化前：无索引查询
SELECT * FROM orders WHERE customer_id = ?

-- 优化后：添加索引
CREATE INDEX idx_customer_id ON orders(customer_id);

// 优化前：N+1查询问题
List<Order> orders = orderRepository.findAll();
for (Order order : orders) {
    Customer customer = customerRepository.findById(order.getCustomerId());
    // 处理订单和客户
}

// 优化后：使用JOIN查询
List<OrderWithCustomer> results = orderRepository.findAllOrdersWithCustomers();

// 优化前：一次性加载所有数据
List<Product> products = productRepository.findAll();

// 优化后：使用分页查询
Page<Product> productPage = productRepository.findAll(
    PageRequest.of(0, 100, Sort.by("name"))
);

// 优化前：单条插入
for (Order order : orders) {
    jdbcTemplate.update("INSERT INTO orders VALUES (?, ?, ?)", 
        order.getId(), order.getCustomerId(), order.getAmount());
}

​​​​​​​// 优化后：批量插入
jdbcTemplate.batchUpdate("INSERT INTO orders VALUES (?, ?, ?)",
    new BatchPreparedStatementSetter() {
        @Override
        public void setValues(PreparedStatement ps, int i) throws SQLException {
            Order order = orders.get(i);
            ps.setLong(1, order.getId());
            ps.setLong(2, order.getCustomerId());
            ps.setBigDecimal(3, order.getAmount());
        }
        
        @Override
        public int getBatchSize() {
            return orders.size();
        }
    });

# 启用JPA批处理
spring.jpa.properties.hibernate.jdbc.batch_size=50
spring.jpa.properties.hibernate.order_inserts=true
spring.jpa.properties.hibernate.order_updates=true

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testStringConcatenation() {
    String result = "";
    for (int i = 0; i < 100; i++) {
        result += i;  // 低效的字符串拼接
    }
}

​​​​​​​@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void testStringBuilder() {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 100; i++) {
        sb.append(i);  // 高效的字符串拼接
    }
    String result = sb.toString();
}

// 优化前：无限制的缓存，可能导致内存泄漏
private static final Map<String, Object> cache = new HashMap<>();

// 优化后：使用Guava缓存，限制大小和过期时间
private static final Cache<String, Object> cache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build();