Java性能优化实战（四）：IO与网络优化的4个关键方向

IO与网络操作是Java应用性能的常见瓶颈，尤其在高并发场景下，低效的IO处理会导致响应缓慢、资源浪费等问题。本文将聚焦IO与网络优化的四个核心方向，通过真实案例、代码对比和性能数据，详解如何提升IO效率、减少网络传输开销，让应用在数据交互中跑得更快。

一、从BIO到NIO/Netty：告别阻塞式IO的性能陷阱

传统的BIO（阻塞IO）在处理多连接时会创建大量线程，导致资源耗尽和响应延迟，而NIO（非阻塞IO）和Netty框架通过多路复用机制，能以少量线程处理大量连接，显著提升并发能力。

BIO的性能困境

BIO采用"一连接一线程"模型，当连接数增加时，线程数急剧增长，引发频繁的上下文切换和内存消耗。

BIO服务器实现（问题代码）：

public class BioServer {public static void main(String[] args) throws IOException {ServerSocket serverSocket = new ServerSocket(8080);System.out.println("BIO服务器启动，端口8080");while (true) {// 阻塞等待客户端连接Socket clientSocket = serverSocket.accept();System.out.println("新客户端连接：" + clientSocket.getInetAddress());// 为每个连接创建新线程处理new Thread(() -> {try (InputStream in = clientSocket.getInputStream();OutputStream out = clientSocket.getOutputStream()) {byte[] buffer = new byte[1024];// 阻塞读取数据int len;while ((len = in.read(buffer)) != -1) {String request = new String(buffer, 0, len);System.out.println("收到请求：" + request);// 处理并响应String response = "已收到：" + request;out.write(response.getBytes());out.flush();}} catch (IOException e) {e.printStackTrace();}}).start();}}
}

问题分析：

每连接一线程导致线程数暴增（10000连接需10000线程）
线程阻塞在accept()和read()操作，CPU利用率低
高并发下频繁的线程上下文切换消耗大量资源

NIO的非阻塞解决方案

NIO通过Selector实现多路复用，单个线程可管理多个通道，仅在通道有数据时才处理，大幅减少线程数量。

NIO服务器实现（优化代码）：

public class NioServer {public static void main(String[] args) throws IOException {// 1. 创建Selector和ServerSocketChannelSelector selector = Selector.open();ServerSocketChannel serverChannel = ServerSocketChannel.open();serverChannel.bind(new InetSocketAddress(8080));serverChannel.configureBlocking(false); // 设置非阻塞serverChannel.register(selector, SelectionKey.OP_ACCEPT);System.out.println("NIO服务器启动，端口8080");while (true) {// 2. 阻塞等待就绪的通道（可设置超时时间）selector.select();// 3. 处理就绪的事件Set<SelectionKey> selectedKeys = selector.selectedKeys();Iterator<SelectionKey> iterator = selectedKeys.iterator();while (iterator.hasNext()) {SelectionKey key = iterator.next();iterator.remove(); // 移除已处理的keyif (key.isAcceptable()) {// 处理新连接ServerSocketChannel server = (ServerSocketChannel) key.channel();SocketChannel clientChannel = server.accept();clientChannel.configureBlocking(false);// 注册读事件clientChannel.register(selector, SelectionKey.OP_READ);System.out.println("新客户端连接：" + clientChannel.getRemoteAddress());} else if (key.isReadable()) {// 处理读事件SocketChannel clientChannel = (SocketChannel) key.channel();ByteBuffer buffer = ByteBuffer.allocate(1024);int len = clientChannel.read(buffer);if (len > 0) {buffer.flip();String request = new String(buffer.array(), 0, len);System.out.println("收到请求：" + request);// 响应客户端String response = "已收到：" + request;clientChannel.write(ByteBuffer.wrap(response.getBytes()));} else if (len == -1) {// 连接关闭clientChannel.close();System.out.println("客户端断开连接");}}}}}
}

Netty：更易用的高性能网络框架

Netty封装了NIO的复杂性，提供更简洁的API和更优的性能，是高并发网络应用的首选。

Netty服务器实现（推荐方案）：

public class NettyServer {public static void main(String[] args) {// 1. 创建两个线程组：boss处理连接，worker处理读写EventLoopGroup bossGroup = new NioEventLoopGroup(1);EventLoopGroup workerGroup = new NioEventLoopGroup();try {// 2. 服务器启动配置ServerBootstrap bootstrap = new ServerBootstrap();bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class) // 使用NIO通道.option(ChannelOption.SO_BACKLOG, 128) // 连接队列大小.childOption(ChannelOption.SO_KEEPALIVE, true) // 保持连接.childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) {// 添加处理器ch.pipeline().addLast(new StringDecoder());ch.pipeline().addLast(new StringEncoder());ch.pipeline().addLast(new NettyServerHandler());}});System.out.println("Netty服务器启动，端口8080");// 3. 绑定端口并启动ChannelFuture future = bootstrap.bind(8080).sync();future.channel().closeFuture().sync();} catch (InterruptedException e) {e.printStackTrace();} finally {// 4. 优雅关闭bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}// 自定义处理器static class NettyServerHandler extends SimpleChannelInboundHandler<String> {@Overrideprotected void channelRead0(ChannelHandlerContext ctx, String msg) {System.out.println("收到请求：" + msg);// 响应客户端ctx.writeAndFlush("已收到：" + msg);}@Overridepublic void channelActive(ChannelHandlerContext ctx) {System.out.println("新客户端连接：" + ctx.channel().remoteAddress());}}
}

性能对比（10000并发连接测试）：

方案	线程数	内存占用	平均响应时间	TPS
BIO	约10000	8.5GB	320ms	3000
NIO	约50	1.2GB	45ms	22000
Netty	约50	1.0GB	30ms	35000

二、缓冲流：减少IO次数的"性能倍增器"

磁盘IO和网络IO的操作成本远高于内存操作，通过缓冲流减少实际IO次数，能显著提升读写性能。

缓冲流的工作原理

缓冲流（BufferedReader/BufferedWriter等）内部维护一个缓冲区，只有当缓冲区满或调用flush()时才会执行实际IO操作，大幅减少物理IO次数。

案例：大文件读取的性能优化

某数据导入工具需要读取1GB的日志文件进行分析，使用普通流时耗时过长。

普通流实现（低效）：

public class FileReaderDemo {public static void main(String[] args) {long startTime = System.currentTimeMillis();try (FileInputStream fis = new FileInputStream("large_file.log");InputStreamReader isr = new InputStreamReader(fis)) {int c;// 每次读取1个字符，导致大量IO操作while ((c = isr.read()) != -1) {// 处理字符...}} catch (IOException e) {e.printStackTrace();}long endTime = System.currentTimeMillis();System.out.println("普通流读取耗时：" + (endTime - startTime) + "ms");// 输出：普通流读取耗时：12800ms}
}

缓冲流优化实现：

public class BufferedReaderDemo {public static void main(String[] args) {long startTime = System.currentTimeMillis();try (FileInputStream fis = new FileInputStream("large_file.log");InputStreamReader isr = new InputStreamReader(fis);// 使用8KB缓冲区的缓冲流BufferedReader br = new BufferedReader(isr, 8192)) {String line;// 每次读取一行，缓冲区满后才实际IOwhile ((line = br.readLine()) != null) {// 处理行数据...}} catch (IOException e) {e.printStackTrace();}long endTime = System.currentTimeMillis();System.out.println("缓冲流读取耗时：" + (endTime - startTime) + "ms");// 输出：缓冲流读取耗时：650ms}
}

优化效果：

读取时间从12800ms降至650ms，性能提升约20倍
IO操作次数从约100万次减少到约13万次
CPU利用率更均衡，避免了频繁IO导致的波动

缓冲流使用技巧

合理设置缓冲区大小：
- 磁盘文件：8KB-64KB（默认8KB）
- 网络流：根据网络带宽调整（通常4KB-32KB）
- 过大的缓冲区会浪费内存，过小则无法发挥缓冲效果
优先使用带缓冲的包装流：
- BufferedReader替代InputStreamReader直接读取
- BufferedWriter替代OutputStreamWriter直接写入
- BufferedInputStream/BufferedOutputStream处理字节流
批量读写：
- 使用read(byte[])或read(char[])批量读取
- 写入时积累到一定量再flush()，减少刷新次数

三、数据库IO优化：从连接到SQL的全方位提速

数据库操作是应用的核心IO场景，优化数据库交互能显著提升整体性能，主要包括连接管理、SQL执行和结果处理三个层面。

连接池：避免频繁创建连接的开销

数据库连接创建成本高，使用连接池复用连接可减少90%以上的连接建立时间。

HikariCP连接池配置（最优实践）：

@Configuration
public class DataSourceConfig {@Beanpublic DataSource dataSource() {HikariConfig config = new HikariConfig();config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");config.setUsername("root");config.setPassword("password");// 核心配置config.setMinimumIdle(5);        // 最小空闲连接config.setMaximumPoolSize(10);   // 最大连接数（根据并发量设置）config.setIdleTimeout(300000);   // 空闲连接超时时间（5分钟）config.setMaxLifetime(1800000);  // 连接最大存活时间（30分钟）config.setConnectionTimeout(30000); // 获取连接超时时间（30秒）// 性能优化配置config.addDataSourceProperty("cachePrepStmts", "true"); // 缓存预处理语句config.addDataSourceProperty("prepStmtCacheSize", "250"); // 预处理语句缓存大小config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048"); // 预处理语句最大长度config.addDataSourceProperty("useServerPrepStmts", "true"); // 使用服务器端预处理return new HikariDataSource(config);}
}

批量操作：减少SQL执行次数

单条SQL操作效率低，批量处理能将多次IO合并为一次，特别适合插入、更新大量数据的场景。

MyBatis批量插入优化：

<!-- 低效：单条插入 -->
<insert id="insertUsers">INSERT INTO user (name, age, email)VALUES (#{name}, #{age}, #{email})
</insert><!-- 优化：批量插入 -->
<insert id="batchInsertUsers">INSERT INTO user (name, age, email)VALUES<foreach collection="list" item="user" separator=",">(#{user.name}, #{user.age}, #{user.email})</foreach>
</insert>

Java代码调用：

@Service
public class UserService {@Autowiredprivate UserMapper userMapper;// 批量插入优化public void batchSaveUsers(List<User> users) {int batchSize = 500; // 每批插入500条int total = users.size();for (int i = 0; i < total; i += batchSize) {int end = Math.min(i + batchSize, total);List<User> batch = users.subList(i, end);userMapper.batchInsertUsers(batch);}}
}

性能对比（插入10000条数据）：

方式	执行时间	SQL执行次数	网络交互次数
单条插入	12500ms	10000次	10000次
批量插入（500条/批）	850ms	20次	20次

其他数据库优化技巧

使用Fetch Size：查询大量数据时设置合适的fetchSize，避免一次性加载全部数据到内存

// JDBC设置fetchSize
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setFetchSize(100); // 每次从数据库获取100条记录

**避免SELECT ***：只查询需要的字段，减少数据传输量
使用索引：为查询条件、排序字段创建合适的索引
合理使用事务：避免长事务占用连接，小事务可合并以减少提交次数

四、网络传输压缩：用CPU换带宽的性能博弈

网络传输中，数据量越大耗时越长，通过压缩减少传输数据量，能显著提升接口响应速度，尤其适合大数据量传输场景。

GZIP压缩：HTTP传输的标准压缩方案

HTTP协议支持GZIP压缩，服务器压缩响应数据，客户端解压，可减少60%-80%的数据传输量。

Spring Boot启用GZIP压缩：

# application.yml
server:compression:enabled: true                 # 启用压缩mime-types: application/json,application/xml,text/html,text/plain  # 压缩的MIME类型min-response-size: 1024       # 最小压缩大小（1KB以上才压缩）compression-level: 6          # 压缩级别（1-9，级别越高压缩率越高但CPU消耗越大）

Netty中添加GZIP压缩：

// 在ChannelPipeline中添加压缩处理器
ch.pipeline().addLast(new HttpServerCodec())// 压缩处理器：对响应进行GZIP压缩.addLast(new HttpContentCompressor(6))  // 压缩级别6.addLast(new MyServerHandler());

自定义数据压缩：非HTTP场景的优化

对于自定义协议的网络传输，可使用GZIP或Snappy等算法手动压缩数据。

Java对象压缩传输示例：

public class CompressionUtils {// 压缩对象public static byte[] compress(Object obj) throws IOException {try (ByteArrayOutputStream baos = new ByteArrayOutputStream();GZIPOutputStream gzos = new GZIPOutputStream(baos)) {// 序列化对象并压缩ObjectOutputStream oos = new ObjectOutputStream(gzos);oos.writeObject(obj);oos.flush();gzos.finish();return baos.toByteArray();}}// 解压对象public static Object decompress(byte[] data) throws IOException, ClassNotFoundException {try (ByteArrayInputStream bais = new ByteArrayInputStream(data);GZIPInputStream gzis = new GZIPInputStream(bais);ObjectInputStream ois = new ObjectInputStream(gzis)) {return ois.readObject();}}
}// 使用示例
public class DataClient {public void sendData(Object data) throws IOException {// 压缩数据byte[] compressedData = CompressionUtils.compress(data);System.out.println("压缩前大小：" + serialize(data).length + "字节");System.out.println("压缩后大小：" + compressedData.length + "字节");// 发送压缩后的数据socket.getOutputStream().write(compressedData);}// 简单序列化（仅用于计算大小）private byte[] serialize(Object obj) throws IOException {try (ByteArrayOutputStream baos = new ByteArrayOutputStream();ObjectOutputStream oos = new ObjectOutputStream(baos)) {oos.writeObject(obj);return baos.toByteArray();}}
}