2025 Java云原生最佳实践：基于腾讯云TKE的JVM内存动态调优与可观测性

jvm-calc/
├── src/main/java/com/tencent/jvm/
│   └── JvmParamGenerator.java
├── pom.xml
└── Dockerfile（用于构建计算器镜像）

package com.tencent.jvm;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

public class JvmParamGenerator {

    private static final long MB = 1024 * 1024;
    
    // 比例可通过环境变量覆盖
    private static final double HEAP_RATIO = getEnvDouble("HEAP_RATIO", 0.70);
    private static final double DIRECT_RATIO = getEnvDouble("DIRECT_RATIO", 0.12);
    private static final double METASPACE_RATIO = getEnvDouble("METASPACE_RATIO", 0.06);
    private static final double CODE_CACHE_RATIO = getEnvDouble("CODE_CACHE_RATIO", 0.04);
    // 预留比例（线程栈、GC开销等）
    private static final double RESERVED_RATIO = 0.08;

    public static void main(String[] args) throws IOException {
        long containerMem = getContainerMemoryLimit();
        if (containerMem <= 0) {
            System.err.println("Failed to read container memory, fallback to physical memory");
            containerMem = Runtime.getRuntime().totalMemory();
        }

        // 总预算检查
        double total = HEAP_RATIO + DIRECT_RATIO + METASPACE_RATIO + CODE_CACHE_RATIO + RESERVED_RATIO;
        if (total > 1.0) {
            throw new IllegalStateException("Total ratio " + total + " exceeds 1.0");
        }

        long heap = (long) (containerMem * HEAP_RATIO);
        long direct = (long) (containerMem * DIRECT_RATIO);
        long metaspaceMax = (long) (containerMem * METASPACE_RATIO);
        long codeCache = (long) (containerMem * CODE_CACHE_RATIO);

        // 元空间初始值（取128m和metaspaceMax的较小值）
        long metaspaceInit = Math.min(128 * MB, metaspaceMax);

        // CPU核心数（自动识别cgroup限制）
        int cpuCores = Runtime.getRuntime().availableProcessors();
        int parallelGCThreads = Math.max(1, cpuCores / 2);
        int concGCThreads = Math.max(1, cpuCores / 4);

        // 构建JVM参数列表
        List<String> opts = new ArrayList<>();
        opts.add("-XX:+UseContainerSupport");
        opts.add("-XX:+UseG1GC");
        opts.add("-Xms" + heap / MB + "m");
        opts.add("-Xmx" + heap / MB + "m");
        opts.add("-XX:MaxDirectMemorySize=" + direct / MB + "m");
        opts.add("-XX:MaxMetaspaceSize=" + metaspaceMax / MB + "m");
        opts.add("-XX:MetaspaceSize=" + metaspaceInit / MB + "m");
        opts.add("-XX:ReservedCodeCacheSize=" + codeCache / MB + "m");
        opts.add("-XX:ParallelGCThreads=" + parallelGCThreads);
        opts.add("-XX:ConcGCThreads=" + concGCThreads);
        opts.add("-XX:+UseStringDeduplication");
        opts.add("-XX:G1HeapWastePercent=5");
        // GC日志输出（便于CLS采集）
        opts.add("-Xlog:gc*:file=/var/log/gc.log:time,uptime,level,tags:filecount=10,filesize=100M");

        // 输出到标准输出，供entrypoint捕获
        String javaOpts = String.join(" ", opts);
        System.out.println(javaOpts);

        // 同时写入文件，便于其他进程读取
        Files.write(Paths.get("/tmp/jvm_opts.txt"), javaOpts.getBytes());
    }

    private static double getEnvDouble(String key, double defaultVal) {
        String val = System.getenv(key);
        if (val != null) {
            try {
                return Double.parseDouble(val);
            } catch (NumberFormatException ignored) {}
        }
        return defaultVal;
    }

    /**
     * 读取容器内存限制，兼容cgroup v2 (K8s 1.24+) 和 v1
     */
    private static long getContainerMemoryLimit() throws IOException {
        // cgroup v2 路径
        String v2Path = "/sys/fs/cgroup/memory.max";
        if (Files.exists(Paths.get(v2Path))) {
            String content = Files.readString(Paths.get(v2Path)).trim();
            if ("max".equals(content)) {
                return getPhysicalMemory();
            }
            return Long.parseLong(content);
        }

        // cgroup v1 路径
        String v1Path = "/sys/fs/cgroup/memory/memory.limit_in_bytes";
        if (Files.exists(Paths.get(v1Path))) {
            long limit = Long.parseLong(Files.readString(Paths.get(v1Path)).trim());
            if (limit > Long.MAX_VALUE / 2) {
                return getPhysicalMemory();
            }
            return limit;
        }

        // 降级
        return getPhysicalMemory();
    }

    private static long getPhysicalMemory() {
        // 使用OperatingSystemMXBean获取准确物理内存
        com.sun.management.OperatingSystemMXBean osBean =
                (com.sun.management.OperatingSystemMXBean) java.lang.management.ManagementFactory.getOperatingSystemMXBean();
        return osBean.getTotalPhysicalMemorySize();
    }
}

FROM eclipse-temurin:21-jre-alpine AS builder
WORKDIR /build
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn clean package

FROM alpine:3.20
RUN apk add --no-cache openjdk21-jre-headless
COPY --from=builder /build/target/jvm-calc-1.0.jar /opt/jvm-calc.jar
ENTRYPOINT ["java", "-jar", "/opt/jvm-calc.jar"]

docker build -t ccr.ccs.tencentyun.com/prod/jvm-calc:latest .
docker push ccr.ccs.tencentyun.com/prod/jvm-calc:latest

FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY app.jar .
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]

#!/bin/sh
set -e

# 运行计算器，输出JAVA_OPTS到标准输出和文件
JAVA_OPTS=$(java -jar /opt/jvm-calc.jar | tail -n 1)

if [ -z "$JAVA_OPTS" ]; then
    # 降级
    JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=70.0"
fi

export JAVA_OPTS
echo "Final JAVA_OPTS: $JAVA_OPTS"

# 启动应用
exec java $JAVA_OPTS -jar /app/app.jar

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
  namespace: production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
      annotations:
        # 开启OTel自动注入（后文可观测性）
        instrumentation.opentelemetry.io/inject-java: "true"
    spec:
      volumes:
      - name: jvm-opts-volume
        emptyDir: {}
      initContainers:
      - name: jvm-calc
        image: ccr.ccs.tencentyun.com/prod/jvm-calc:latest
        env:
        - name: HEAP_RATIO
          value: "0.70"
        - name: DIRECT_RATIO
          value: "0.12"
        volumeMounts:
        - name: jvm-opts-volume
          mountPath: /output
        # 将计算器输出重定向到共享卷
        command: ["sh", "-c", "java -jar /opt/jvm-calc.jar | tee /output/jvm_opts.txt"]
      containers:
      - name: app
        image: ccr.ccs.tencentyun.com/prod/order-service:latest
        ports:
        - containerPort: 8080
        env:
        - name: JAVA_OPTS
          valueFrom:
            configMapKeyRef:
              name: jvm-opts-config  # 我们将在启动时从文件读取，但可先留空
        volumeMounts:
        - name: jvm-opts-volume
          mountPath: /jvm-opts
        # 启动脚本改为读取共享卷中的参数
        command: ["sh", "-c", "export JAVA_OPTS=$(cat /jvm-opts/jvm_opts.txt); exec java $JAVA_OPTS -jar /app/app.jar"]
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10

[FILTER]
    Name          parser
    Match         kube.order-service*
    Key_Name      log
    Parser        gc_log_parser
[PARSER]
    Name          gc_log_parser
    Format        regex
    Regex         ^(?<timestamp>[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]+)\+[0-9:]+ (?<gc_type>\w+) .*$

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: order-service-monitor
  namespace: production
spec:
  selector:
    matchLabels:
      app: order-service
  endpoints:
  - port: web
    path: /actuator/prometheus