[Java实战]Springboot项目高并发性能优化

zhezhongyun 2025-06-10 04:05 2 浏览

一、测试验证结果

1.1 功能测试

#优化前
 curl -X POST http://127.0.0.1:8080/api/users   -H "Content-Type: application/json"   -d '{"name":"张三","email":"zhangsan@example.com"}'   -v

#优化后
 curl -X POST http://127.0.0.1:8081/api/users   -H "Content-Type: application/json"   -d '{"name":"张三","email":"zhangsan@example.com"}'   -v

1.2 性能测试

优化前：12000 qps
优化后：36000 qps

1.3 代码运行截图

二、问题根因分析

2.1 线程模型瓶颈

Spring Boot默认的Tomcat容器使用BIO/NIO模型，每个请求占用1个线程，当长连接数超过线程池容量时会发生排队甚至拒绝

2.2 同步阻塞处理

若业务逻辑中存在同步阻塞操作（如同步数据库查询），会快速耗尽线程资源

2.3 上下文切换开销

大量线程导致CPU时间片频繁切换，实际有效利用率降低

三、Netty替代方案（针对高并发长连接场景）

3.1 原架构

package com.example.controller;

import com.example.model.User;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;

@RestController
@RequestMapping("/api")
public class ApiController {

    private final List<User> users = new ArrayList<>();
    private final AtomicLong counter = new AtomicLong();

    // 测试接口
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }

    // 获取所有用户
    @GetMapping("/users")
    public List<User> getAllUsers() {
        return users;
    }

    // 创建用户
    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        user.setId(counter.incrementAndGet());
        users.add(user);
        return user;
    }

    // 根据ID查询用户
    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return users.stream()
                .filter(u -> u.getId().equals(id))
                .findFirst()
                .orElseThrow(() -> new RuntimeException("User not found"));
    }

    // 更新用户
    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        User user = users.stream()
                .filter(u -> u.getId().equals(id))
                .findFirst()
                .orElseThrow(() -> new RuntimeException("User not found"));

        user.setName(userDetails.getName());
        user.setEmail(userDetails.getEmail());
        return user;
    }

    // 删除用户
    @DeleteMapping("/users/{id}")
    public String deleteUser(@PathVariable Long id) {
        users.removeIf(u -> u.getId().equals(id));
        return "User deleted successfully";
    }
}

3.2. 整体架构调整（推荐方案）

package com.example.demo;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.timeout.IdleStateHandler;
import io.netty.handler.traffic.ChannelTrafficShapingHandler;
import io.netty.util.concurrent.DefaultThreadFactory;

import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.util.concurrent.TimeUnit;

public class NettyServer {
    // 监控指标（生产环境建议使用Prometheus等专业工具）
    private static int activeConnections = 0;

    public static void main(String[] args) {
        // 优化线程池配置
        EventLoopGroup bossGroup = new NioEventLoopGroup(1, new DefaultThreadFactory("boss"));
        EventLoopGroup workerGroup = new NioEventLoopGroup(
                Runtime.getRuntime().availableProcessors() * 2,
                new DefaultThreadFactory("worker")
        );

        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 内存池优化
                            pipeline.addLast(new ChannelTrafficShapingHandler(1024 * 1024, 1024 * 1024));
                            // HTTP协议处理
                            pipeline.addLast(new HttpServerCodec());
                            pipeline.addLast(new HttpObjectAggregator(10 * 1024 * 1024));
                            // 超时控制（读超时60秒）
                            pipeline.addLast(new IdleStateHandler(60, 0, 0, TimeUnit.SECONDS));
                            // 监控处理器
                            pipeline.addLast(new ConnectionMonitorHandler());
                            // 业务逻辑处理器
                            pipeline.addLast(new BusinessHandler());
                            // 统一异常处理
                            pipeline.addLast(new GlobalExceptionHandler());
                        }
                    })
                    // 服务器参数优化
                    .option(ChannelOption.SO_BACKLOG, 65535)
                    .option(ChannelOption.SO_REUSEADDR, true)
                    .childOption(ChannelOption.TCP_NODELAY, true)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK,
                            new WriteBufferWaterMark(8 * 1024, 32 * 1024))
                    .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);

            // 绑定端口并添加监听器
            ChannelFuture f = b.bind(8081)
                    .addListener((ChannelFutureListener) future -> {
                        if (future.isSuccess()) {
                            System.out.println("================服务启动成功 端口: 8081====================");
                            printSystemInfo();
                        } else {
                            System.err.println("端口绑定失败: " + future.cause().getMessage());
                            System.exit(1);
                        }
                    })
                    .sync();

            // 添加关闭钩子
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                bossGroup.shutdownGracefully();
                workerGroup.shutdownGracefully();
                System.out.println("服务已优雅关闭");
            }));

            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    // 监控处理器
    @ChannelHandler.Sharable
    private static class ConnectionMonitorHandler extends ChannelDuplexHandler {
        @Override
        public void channelActive(ChannelHandlerContext ctx) {
            activeConnections++;
            ctx.fireChannelActive();
        }

        @Override
        public void channelInactive(ChannelHandlerContext ctx) {
            activeConnections--;
            ctx.fireChannelInactive();
        }
    }

    // 全局异常处理
    @ChannelHandler.Sharable
    private static class GlobalExceptionHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            if (cause instanceof IOException && "Connection reset by peer".equals(cause.getMessage())) {
                System.out.println("客户端强制断开: " + ctx.channel().remoteAddress());
                ctx.close();
            } else {
                System.err.println("未处理异常: ");
                cause.printStackTrace();
                ctx.close();
            }
        }
    }

    // 系统信息打印
    private static void printSystemInfo() {
        System.out.println("当前配置参数：");
        System.out.println("CPU核心数: " + Runtime.getRuntime().availableProcessors());
        System.out.println("最大内存: " + Runtime.getRuntime().maxMemory() / 1024 / 1024 + "MB");
        System.out.println("JVM参数: " + ManagementFactory.getRuntimeMXBean().getInputArguments());
    }
}

3.3 关键优化点

异步非阻塞处理：所有IO操作在NIO线程完成，业务处理移交独立线程池
连接管理优化：

// 限制最大连接数
public class ConnectionLimiter extends ChannelInboundHandlerAdapter {
    private static final AtomicInteger connections = new AtomicInteger(0);
    private static final int MAX_CONN = 10000;

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        if (connections.incrementAndGet() > MAX_CONN) {
            ctx.close();
            return;
        }
        // 正常处理
    }
}

协议优化：采用二进制协议（如Protobuf）替代JSON，降低序列化开销

四、Spring Boot整合方案（兼容现有服务）

4.1 混合部署模式

// 在Spring Boot中启动Netty
@SpringBootApplication
public class HybridApp {
    public static void main(String[] args) {
        SpringApplication.run(HybridApp.class, args);
        new NettyServer().start();  // 启动Netty服务
    }
}

// 配置不同的端口
server.port=8080   # Spring MVC端口
netty.port=8081    # Netty服务端口

4.2 服务分流策略

将高频长连接请求（如即时消息、实时定位）路由到Netty服务
保留Spring MVC处理RESTful短连接请求

五、补充优化措施

5.1 业务逻辑优化

-// 异步处理模板
public class AsyncProcessor {
    private static final Executor bizExecutor = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors() * 2); // 独立业务线程池

    public void process(ChannelHandlerContext ctx, Object msg) {
        CompletableFuture.supplyAsync(() -> {
            // 业务处理逻辑
            return processBusiness(msg);
        }, bizExecutor).thenAcceptAsync(result -> {
            ctx.writeAndFlush(result);
        }, ctx.executor()); // 回到IO线程写响应
    }
}

5.2 监控配置

<!-- Netty自带监控 -->
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-monitor</artifactId>
    <version>${netty.version}</version>
</dependency>

// 连接数监控
public class ConnectionMonitor extends ChannelInboundHandlerAdapter {
    private static final Counter connections = Metrics.counter("netty.connections");

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        connections.increment();
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        connections.decrement();
    }
}

六、实施建议

6.1 分阶段改造

先对压力最大的接口进行Netty改造

6.2 压力测试

使用wrk进行对比测试

# 测试命令示例
 ./wrk -t12 -c400 -d30s -T5s -s post_test.lua http://localhost:8081/api/users

6.3 监控指标

重点关注qps、cpu利用率、gc次数等核心指标

改造后预期效果（经验值）：

连接容量提升：从Tomcat默认200~500提升到10,000+
CPU利用率下降：相同压力下可降低30%-50%
内存消耗：减少线程栈内存占用（每个线程约1MB）

建议先通过jstack分析当前线程状态，确认是否真的是线程数过多导致的问题，再针对性优化。同时要确保业务代码没有同步阻塞操作，必要时结合Arthas进行线上诊断。

希望这篇文章对你有所帮助！如果觉得不错，别忘了点赞收藏哦！

counter-increment 属性

[Java实战]Springboot项目高并发性能优化

一、测试验证结果

1.1 功能测试

1.2 性能测试

1.3 代码运行截图

二、问题根因分析

2.1 线程模型瓶颈

2.2 同步阻塞处理

2.3 上下文切换开销

三、Netty替代方案（针对高并发长连接场景）

3.1 原架构

3.2. 整体架构调整（推荐方案）

3.3 关键优化点

四、Spring Boot整合方案（兼容现有服务）

4.1 混合部署模式

4.2 服务分流策略

五、补充优化措施

5.1 业务逻辑优化

5.2 监控配置

六、实施建议

6.1 分阶段改造

6.2 压力测试

6.3 监控指标

相关推荐

b端详情页:各种信息聚集地，设计师要如何规划这一亩三分地呢

接口测试遇到500报错?别慌，你的头部可能有点问题

漏洞系列一一看我一招征服漏洞 SSRF

Web前端需要学什么?Web前端开发需要学习哪些?

前端Flex布局可视化布局工具介绍，vue和html5快速设计利器

「资讯」为强迫用户使用Edge浏览器，微软又出新招数

HTML 简介（html简介及优缺点）

HBuilderX，uni-app创建HTML5项目，同时支持浏览器和移动端

关于HTML5被简称做H5，你怎么看?（html5缩写）

现在页面实时聊天都使用Websocket技术实现吗?