全链路压测硬核实战：从方案落地、瓶颈根因定位到全链路性能优化

// 错误写法：循环内调用数据库，产生N次数据库交互，性能极差
public List<OrderVO> getOrderList(List<Long> orderIds) {
    List<OrderVO> orderVOList = new ArrayList<>();
    for (Long orderId : orderIds) {
        Order order = orderMapper.selectById(orderId);
        orderVOList.add(convert(order));
    }
    return orderVOList;
}

// 正确写法：批量查询，仅1次数据库交互，性能提升数十倍
public List<OrderVO> getOrderList(List<Long> orderIds) {
    List<Order> orderList = orderMapper.selectBatchIds(orderIds);
    return orderList.stream().map(this::convert).toList();
}

-Xms8g -Xmx8g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:+ParallelRefProcEnabled -XX:MaxMetaspaceSize=1g -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/var/log/jvm/heapdump.hprof -XX:+UnlockExperimentalVMOptions -XX:+UseStringDeduplication -XX:+DisableExplicitGC

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.*;

@Configuration
publicclass ThreadPoolConfig {
    // 获取服务器CPU核心数
    privatestaticfinalint CPU_CORE = Runtime.getRuntime().availableProcessors();

    // IO密集型任务线程池：适用于数据库、Redis、RPC调用等IO阻塞型任务
    @Bean("ioTaskExecutor")
    public ExecutorService ioTaskExecutor() {
        returnnew ThreadPoolExecutor(
                CPU_CORE * 2,
                CPU_CORE * 4,
                60L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(CPU_CORE * 20),
                new ThreadFactory() {
                    privateint threadCount = 0;
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r, "io-task-pool-" + (++threadCount));
                        thread.setDaemon(true);
                        return thread;
                    }
                },
                // 自定义拒绝策略：快速失败，触发降级
                (r, executor) -> {
                    thrownew RuntimeException("系统繁忙，请稍后再试");
                }
        );
    }

    // CPU密集型任务线程池：适用于加密、计算、序列化等CPU消耗型任务
    @Bean("cpuTaskExecutor")
    public ExecutorService cpuTaskExecutor() {
        returnnew ThreadPoolExecutor(
                CPU_CORE + 1,
                CPU_CORE * 2,
                60L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(CPU_CORE * 10),
                new ThreadFactory() {
                    privateint threadCount = 0;
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread(r, "cpu-task-pool-" + (++threadCount));
                        thread.setDaemon(true);
                        return thread;
                    }
                },
                // 调用者执行策略：避免任务丢失，降低提交速度
                new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
}

SELECT id,order_no,user_id,order_status,create_time FROM t_order WHERE user_id = 123 AND order_status = 0 ORDER BY create_time DESC LIMIT 10;

CREATE INDEX idx_userid_status_createtime ON t_order (user_id, order_status, create_time);

-- 错误写法：深分页，会扫描100010行数据，性能极差
SELECT * FROM t_order ORDERBYidDESCLIMIT100000, 10;

-- 正确写法：主键过滤，仅扫描10行数据，性能提升上万倍
SELECT * FROM t_order WHEREid < 100000ORDERBYidDESCLIMIT10;

[mysqld]
# 内存核心配置
innodb_buffer_pool_size = 10G
innodb_log_buffer_size = 64M
innodb_log_file_size = 2G
# 连接配置
max_connections = 1000
wait_timeout = 600
interactive_timeout = 600
# IO性能配置
innodb_flush_log_at_trx_commit = 1
sync_binlog = 1
innodb_io_capacity = 2000
innodb_io_capacity_max = 4000
# 慢查询日志配置
slow_query_log = ON
long_query_time = 1
log_queries_not_using_indexes = ON
# 事务与锁配置
transaction_isolation = READ-COMMITTED
innodb_lock_wait_timeout = 5
# 字符集配置
character_set_server = utf8mb4
collation_server = utf8mb4_unicode_ci

# /etc/sysctl.conf
# TCP核心优化
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_timestamps = 1
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 30
net.ipv4.tcp_keepalive_probes = 3
# 连接队列优化
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
# 缓冲区优化
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
# 内核优化
vm.swappiness = 0
vm.overcommit_memory = 1
vm.dirty_ratio = 10
vm.dirty_background_ratio = 5

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.5</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>order-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>order-service</name>
    <description>Order Service</description>
    <properties>
        <java.version>21</java.version>
        <spring-cloud.version>2023.0.3</spring-cloud.version>
        <mybatis-plus.version>3.5.7</mybatis-plus.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>2023.0.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.apache.skywalking</groupId>
            <artifactId>apm-toolkit-trace</artifactId>
            <version>9.7.0</version>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import feign.FeignException;
import lombok.Data;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;

// 订单实体类
@Data
@TableName("t_order")
publicclass Order {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Long productId;
    private Integer count;
    private Integer orderStatus;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

// 订单Mapper接口
publicinterface OrderMapper extends BaseMapper<Order> {}

// 库存服务Feign客户端
@FeignClient(name = "stock-service")
publicinterface StockFeignClient {
    @PostMapping("/stock/deduct")
    Boolean deductStock(@RequestParam Long productId, @RequestParam Integer count);
}

// 支付服务Feign客户端
@FeignClient(name = "pay-service")
publicinterface PayFeignClient {
    @PostMapping("/pay/create")
    Long createPayOrder(@RequestParam Long orderId, @RequestParam Long userId, @RequestParam Integer amount);
}

// 下单请求DTO
@Data
publicclass OrderCreateDTO {
    private Long userId;
    private Long productId;
    private Integer count;
}

// 订单服务接口
@RestController
@RequestMapping("/order")
publicclass OrderController {
    privatefinal OrderMapper orderMapper;
    privatefinal StockFeignClient stockFeignClient;
    privatefinal PayFeignClient payFeignClient;

    // Spring Boot 3.x推荐的构造器注入
    public OrderController(OrderMapper orderMapper, StockFeignClient stockFeignClient, PayFeignClient payFeignClient) {
        this.orderMapper = orderMapper;
        this.stockFeignClient = stockFeignClient;
        this.payFeignClient = payFeignClient;
    }

    @PostMapping("/create")
    @Trace(operationName = "createOrder")
    public String createOrder(@RequestBody OrderCreateDTO dto) {
        // 1. 调用库存服务扣减库存
        Boolean deductResult;
        try {
            deductResult = stockFeignClient.deductStock(dto.getProductId(), dto.getCount());
        } catch (FeignException e) {
            return"库存扣减失败：" + e.getMessage();
        }
        if (!deductResult) {
            return"库存不足，下单失败";
        }
        // 2. 创建订单
        Order order = new Order();
        order.setUserId(dto.getUserId());
        order.setProductId(dto.getProductId());
        order.setCount(dto.getCount());
        order.setOrderStatus(0);
        order.setCreateTime(LocalDateTime.now());
        order.setUpdateTime(LocalDateTime.now());
        orderMapper.insert(order);
        // 3. 调用支付服务创建支付单
        Long payOrderId;
        try {
            payOrderId = payFeignClient.createPayOrder(order.getId(), dto.getUserId(), dto.getCount() * 100);
        } catch (FeignException e) {
            return"支付单创建失败：" + e.getMessage();
        }
        return"下单成功，订单号：" + order.getId() + "，支付单号：" + payOrderId;
    }
}

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

// 库存实体类
@Data
@TableName("t_stock")
publicclass Stock {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long productId;
    private Integer stockNum;
}

// 库存Mapper接口
publicinterface StockMapper extends BaseMapper<Stock> {}

// 库存服务接口
@RestController
@RequestMapping("/stock")
publicclass StockController {
    privatefinal StockMapper stockMapper;

    public StockController(StockMapper stockMapper) {
        this.stockMapper = stockMapper;
    }

    @PostMapping("/deduct")
    @Transactional(rollbackFor = Exception.class)
    public Boolean deductStock(@RequestParam Long productId, @RequestParam Integer count) {
        int updateRows = stockMapper.update(
                "UPDATE t_stock SET stock_num = stock_num - ? WHERE product_id = ? AND stock_num >= ?",
                count, productId, count
        );
        return updateRows > 0;
    }
}

CREATE UNIQUE INDEX uk_product_id ON t_stock (product_id);