Java性能优化

在Java应用开发中，性能优化是一个重要的话题。良好的性能优化可以显著提升应用的响应速度、吞吐量和资源利用率。本文将详细介绍Java性能优化的各个方面，包括JVM调优、代码优化、多线程优化、IO优化等内容。

性能优化概述

什么是性能优化？

性能优化是指通过各种技术手段，提升软件系统的性能指标，如响应时间、吞吐量、资源利用率等，同时保持功能正确性。

性能优化的目标

响应时间：减少系统响应用户请求的时间
吞吐量：增加系统单位时间内处理的请求数量
资源利用率：更高效地利用CPU、内存、磁盘IO等系统资源
可扩展性：系统在负载增加时仍能保持良好性能

性能优化的原则

数据驱动：基于实际测量的数据进行优化，而不是主观猜测
先定位瓶颈：先找出性能瓶颈，再进行有针对性的优化
循序渐进：逐步优化，每步优化后都进行验证
保持平衡：在性能、功能、可维护性之间找到平衡点
考虑成本：优化的收益应大于投入的成本

JVM性能调优

JVM内存模型

了解JVM内存模型是进行JVM调优的基础。JVM内存主要分为以下几个区域：

程序计数器：记录当前线程执行的字节码行号
Java虚拟机栈：存储局部变量表、操作数栈、方法出口等信息
本地方法栈：为Native方法提供内存空间
Java堆：存储对象实例，是GC的主要区域
方法区：存储类信息、常量、静态变量等数据
运行时常量池：方法区的一部分，存储字面量和符号引用

JVM内存参数调优

堆内存设置

bash

# 设置初始堆内存和最大堆内存
-Xms512m -Xmx1024m

# 设置新生代大小
-Xmn256m

# 设置老年代和新生代的比例（默认2:1）
-XX:NewRatio=2

# 设置Eden区和Survivor区的比例（默认8:1:1）
-XX:SurvivorRatio=8

垃圾收集器选择

bash

# 使用Serial垃圾收集器
-XX:+UseSerialGC

# 使用ParNew垃圾收集器
-XX:+UseParNewGC

# 使用Parallel Scavenge垃圾收集器
-XX:+UseParallelGC

# 使用Parallel Old垃圾收集器
-XX:+UseParallelOldGC

# 使用CMS垃圾收集器
-XX:+UseConcMarkSweepGC

# 使用G1垃圾收集器（Java 9+默认）
-XX:+UseG1GC

# 使用ZGC垃圾收集器（Java 11+）
-XX:+UseZGC

# 使用Shenandoah垃圾收集器（Java 12+）
-XX:+UseShenandoahGC

GC相关参数

bash

# 设置最大GC暂停时间目标（G1收集器）
-XX:MaxGCPauseMillis=200

# 设置吞吐量目标（Parallel收集器）
-XX:GCTimeRatio=99

# 设置自适应大小调整的最小堆空间（Parallel收集器）
-XX:MinHeapFreeRatio=40

# 设置自适应大小调整的最大堆空间（Parallel收集器）
-XX:MaxHeapFreeRatio=70

# 打印GC详细信息
-XX:+PrintGCDetails

# 打印GC时间戳
-XX:+PrintGCDateStamps

# 将GC日志输出到文件
-Xloggc:gc.log

垃圾收集器选择策略

Serial收集器：适用于单线程环境，Client模式，桌面应用
ParNew收集器：多线程版Serial，适用于多核CPU环境
Parallel Scavenge收集器：注重吞吐量，适用于后台计算任务
CMS收集器：注重低延迟，适用于响应时间敏感的应用
G1收集器：平衡吞吐量和延迟，适用于大堆内存环境
ZGC/Shenandoah：极低延迟收集器，适用于超大规模堆内存

JVM调优案例

假设我们有一个Web应用，出现了频繁的Full GC，响应时间变长。我们可以通过以下步骤进行调优：

收集GC日志：添加-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:gc.log参数
分析GC日志：使用工具如GCViewer、GCEasy等分析GC日志
调整堆内存：根据分析结果，调整-Xms和-Xmx参数
选择合适的收集器：如果是响应时间敏感的应用，可以考虑使用G1或CMS收集器
调整GC参数：设置合理的GC暂停时间目标

Java代码优化

基本数据类型优先

使用基本数据类型而不是包装类，可以减少内存占用和对象创建开销。

java

// 不推荐
Integer sum = 0;
for (int i = 0; i < 10000; i++) {
    sum += i; // 每次都会创建新的Integer对象
}

// 推荐
int sum = 0;
for (int i = 0; i < 10000; i++) {
    sum += i;
}

StringBuilder/StringBuffer

字符串拼接时，使用StringBuilder（单线程）或StringBuffer（多线程）代替+运算符。

java

// 不推荐
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i; // 每次都会创建新的String对象
}

// 推荐
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

集合框架优化

集合初始化大小

为集合指定合适的初始容量，避免频繁扩容。

java

// 不推荐
List<String> list = new ArrayList<>(); // 默认初始容量为10

// 推荐（已知大致元素数量）
List<String> list = new ArrayList<>(100);

// HashMap优化
Map<String, String> map = new HashMap<>(100, 0.75f); // 负载因子可以调整

遍历方式选择

java

List<String> list = new ArrayList<>();

// 1. 增强for循环（简洁）
for (String item : list) {
    // 处理item
}

// 2. 普通for循环（需要索引时）
for (int i = 0; i < list.size(); i++) {
    String item = list.get(i);
    // 处理item
}

// 3. Iterator（需要在遍历中删除元素时）
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    if (condition) {
        iterator.remove(); // 安全删除
    }
}

// 4. Java 8+ Stream API（函数式风格）
list.stream()
    .filter(item -> condition)
    .forEach(item -> { /* 处理item */ });

对象池

对于频繁创建和销毁的对象，可以使用对象池来复用对象。

java

import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

// 创建对象池配置
GenericObjectPoolConfig<Connection> config = new GenericObjectPoolConfig<>();
config.setMaxTotal(100);
config.setMaxIdle(50);
config.setMinIdle(10);

// 创建对象池
GenericObjectPool<Connection> pool = new GenericObjectPool<>(new ConnectionFactory(), config);

// 从池中获取对象
Connection conn = pool.borrowObject();

// 使用对象
// ...

// 归还对象到池
pool.returnObject(conn);

避免不必要的对象创建

java

// 不推荐
public String getString() {
    return new String("hello"); // 每次都创建新对象
}

// 推荐
public String getString() {
    return "hello"; // 使用字符串常量池
}

// 不推荐
for (int i = 0; i < 1000; i++) {
    Date date = new Date(); // 循环内创建对象
    // 使用date
}

// 推荐
Date date = new Date();
for (int i = 0; i < 1000; i++) {
    // 使用date
    date.setTime(System.currentTimeMillis()); // 重置时间
}

缓存使用

使用缓存减少重复计算和数据库访问。

java

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

// 创建缓存
Cache<String, Object> cache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build();

// 从缓存获取数据（如果不存在则计算）
Object value = cache.get(key, () -> computeValue(key));

// 手动放入缓存
cache.put(key, value);

// 移除缓存项
cache.invalidate(key);

多线程性能优化

线程池优化

使用线程池管理线程，避免频繁创建和销毁线程的开销。

java

import java.util.concurrent.*;

// 创建线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, // 核心线程数
    20, // 最大线程数
    60L, TimeUnit.SECONDS, // 空闲线程存活时间
    new LinkedBlockingQueue<>(100), // 工作队列
    new ThreadFactory() {
        private final AtomicInteger counter = new AtomicInteger(0);
        
        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "worker-" + counter.incrementAndGet());
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

// 提交任务
Future<String> future = executor.submit(() -> {
    // 任务逻辑
    return "result";
});

// 获取结果
String result = future.get();

// 关闭线程池
// executor.shutdown();

线程池参数调优

核心线程数：根据CPU核心数和任务类型确定
- CPU密集型任务：核心线程数 = CPU核心数 + 1
- IO密集型任务：核心线程数 = CPU核心数 * 2
最大线程数：根据系统资源和任务特性确定
工作队列：根据任务处理速度和内存情况选择合适的队列类型
- LinkedBlockingQueue：无界队列，适合任务处理速度较快的场景
- ArrayBlockingQueue：有界队列，适合对内存控制严格的场景
- SynchronousQueue：无缓冲队列，适合需要快速响应的场景
拒绝策略：根据业务需求选择合适的拒绝策略
- AbortPolicy：直接抛出异常
- CallerRunsPolicy：由调用者线程执行任务
- DiscardPolicy：直接丢弃任务
- DiscardOldestPolicy：丢弃队列中最老的任务

减少锁竞争

锁粒度优化

java

// 不推荐（锁粒度太大）
public synchronized void method() {
    // 不需要同步的代码
    // 需要同步的代码
    // 不需要同步的代码
}

// 推荐（锁粒度细化）
public void method() {
    // 不需要同步的代码
    synchronized (this) {
        // 需要同步的代码
    }
    // 不需要同步的代码
}

使用并发集合

java

// 不推荐（使用同步集合）
List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());

// 推荐（使用并发集合）
List<String> concurrentList = new CopyOnWriteArrayList<>();
Set<String> concurrentSet = new CopyOnWriteArraySet<>();
Map<String, String> concurrentMap = new ConcurrentHashMap<>();
Queue<String> concurrentQueue = new ConcurrentLinkedQueue<>();
BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<>();

使用读写锁

对于读多写少的场景，使用读写锁可以提高并发性能。

java

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

ReadWriteLock rwLock = new ReentrantReadWriteLock();

// 读操作（共享锁）
public void read() {
    rwLock.readLock().lock();
    try {
        // 读操作逻辑
    } finally {
        rwLock.readLock().unlock();
    }
}

// 写操作（排他锁）
public void write() {
    rwLock.writeLock().lock();
    try {
        // 写操作逻辑
    } finally {
        rwLock.writeLock().unlock();
    }
}

使用原子类

对于简单的原子操作，使用原子类可以避免使用锁，提高性能。

java

import java.util.concurrent.atomic.*;

// 原子整数
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet(); // 原子递增
count.getAndIncrement(); // 原子递增（先获取后递增）
count.addAndGet(10); // 原子增加指定值
count.compareAndSet(0, 1); // CAS操作

// 原子引用
AtomicReference<User> userRef = new AtomicReference<>();
userRef.set(new User());
userRef.compareAndSet(oldUser, newUser);

// 原子更新器
AtomicIntegerFieldUpdater<User> ageUpdater = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
ageUpdater.incrementAndGet(user);

IO性能优化

NIO vs BIO

Java NIO（New IO）提供了非阻塞IO操作，可以显著提高IO密集型应用的性能。

java

// 使用NIO读取文件
try (FileChannel channel = new FileInputStream("file.txt").getChannel();
     ByteBuffer buffer = ByteBuffer.allocateDirect(1024)) {
    
    while (channel.read(buffer) != -1) {
        buffer.flip(); // 切换到读模式
        
        // 读取数据
        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }
        
        buffer.clear(); // 清空缓冲区，切换到写模式
    }
    
} catch (IOException e) {
    e.printStackTrace();
}

使用缓冲流

使用缓冲流可以减少物理IO操作次数。

java

// 使用缓冲流读取文件
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        // 处理每一行
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 使用缓冲流写入文件
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    writer.write("Hello, World!");
    writer.newLine();
    writer.flush(); // 手动刷新缓冲区
} catch (IOException e) {
    e.printStackTrace();
}

文件操作优化

java

// 1. 使用RandomAccessFile进行随机访问
try (RandomAccessFile file = new RandomAccessFile("data.txt", "rw")) {
    file.seek(100); // 跳转到指定位置
    file.write("Hello".getBytes());
} catch (IOException e) {
    e.printStackTrace();
}

// 2. 使用内存映射文件提高大文件读写性能
try (FileChannel channel = new RandomAccessFile("largefile.dat", "rw").getChannel()) {
    MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, channel.size());
    
    // 直接操作内存映射缓冲区
    for (int i = 0; i < buffer.capacity(); i++) {
        buffer.put(i, (byte) (i % 256));
    }
    
    buffer.force(); // 强制写入磁盘
} catch (IOException e) {
    e.printStackTrace();
}

网络IO优化

使用NIO的Selector

Selector允许一个线程管理多个Channel，适合高并发网络应用。

java

// 创建Selector
Selector selector = Selector.open();

// 配置ServerSocketChannel
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.socket().bind(new InetSocketAddress(8080));
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

// 处理连接
while (true) {
    selector.select(); // 阻塞，直到有事件发生
    
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
    
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        keyIterator.remove();
        
        if (key.isAcceptable()) {
            // 接受新连接
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
            SocketChannel client = server.accept();
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            // 读取数据
            SocketChannel client = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int bytesRead = client.read(buffer);
            
            if (bytesRead == -1) {
                client.close();
            } else if (bytesRead > 0) {
                buffer.flip();
                // 处理读取的数据
                // ...
                
                // 注册写事件
                key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
            }
        } else if (key.isWritable()) {
            // 写入数据
            SocketChannel client = (SocketChannel) key.channel();
            // 写入逻辑
            // ...
            
            // 取消写事件注册
            key.interestOps(SelectionKey.OP_READ);
        }
    }
}

使用Netty框架

Netty是一个高性能的异步事件驱动的网络应用程序框架，简化了网络编程。

java

// 创建服务器启动类
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(new NioEventLoopGroup(), new NioEventLoopGroup())
    .channel(NioServerSocketChannel.class)
    .childHandler(new ChannelInitializer<SocketChannel>() {
        @Override
        protected void initChannel(SocketChannel ch) throws Exception {
            ChannelPipeline pipeline = ch.pipeline();
            pipeline.addLast(new StringDecoder());
            pipeline.addLast(new StringEncoder());
            pipeline.addLast(new ServerHandler());
        }
    })
    .option(ChannelOption.SO_BACKLOG, 128)
    .childOption(ChannelOption.SO_KEEPALIVE, true);

// 绑定端口
ChannelFuture future = bootstrap.bind(8080).sync();

// 等待服务器关闭
future.channel().closeFuture().sync();

数据库性能优化

JDBC优化

java

// 1. 使用连接池
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
dataSource.setUser("username");
dataSource.setPassword("password");
dataSource.setMaxPoolSize(20);
dataSource.setMinPoolSize(5);

// 2. 使用PreparedStatement代替Statement
try (Connection conn = dataSource.getConnection();
     PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?")) {
    
    pstmt.setInt(1, userId); // 参数化查询
    try (ResultSet rs = pstmt.executeQuery()) {
        while (rs.next()) {
            // 处理结果集
        }
    }
}

// 3. 批量操作
try (Connection conn = dataSource.getConnection();
     PreparedStatement pstmt = conn.prepareStatement("INSERT INTO users (name, email) VALUES (?, ?)")) {
    
    conn.setAutoCommit(false); // 开启事务
    
    for (User user : userList) {
        pstmt.setString(1, user.getName());
        pstmt.setString(2, user.getEmail());
        pstmt.addBatch(); // 添加到批处理
    }
    
    pstmt.executeBatch(); // 执行批处理
    conn.commit(); // 提交事务
    
} catch (SQLException e) {
    conn.rollback(); // 回滚事务
}

// 4. 使用可滚动和可更新的结果集
try (Connection conn = dataSource.getConnection();
     Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
     ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
    
    rs.afterLast(); // 移动到结果集末尾
    while (rs.previous()) { // 反向遍历
        // 处理数据
    }
    
    rs.first();
    rs.updateString("name", "New Name"); // 更新数据
    rs.updateRow();
    
} catch (SQLException e) {
    e.printStackTrace();
}

SQL优化

使用索引：为经常查询的列创建索引
避免全表扫描：使用WHERE子句过滤数据
使用LIMIT：限制返回的行数
优化JOIN操作：小表驱动大表，使用合适的JOIN类型
**避免SELECT ***：只查询需要的列
使用EXPLAIN分析SQL执行计划

sql

-- 优化前
SELECT * FROM users WHERE age > 18;

-- 优化后
SELECT id, name, email FROM users WHERE age > 18 LIMIT 100;

-- 使用EXPLAIN分析
EXPLAIN SELECT id, name, email FROM users WHERE age > 18 LIMIT 100;

ORM框架优化

Hibernate优化

java

// 1. 使用延迟加载
@OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
private List<Order> orders;

// 2. 使用批量获取
@BatchSize(size = 20)
@OneToMany(fetch = FetchType.LAZY, mappedBy = "user")
private List<Order> orders;

// 3. 使用查询缓存
Session session = sessionFactory.getCurrentSession();
Query query = session.createQuery("FROM User WHERE age > :age");
query.setParameter("age", 18);
query.setCacheable(true); // 启用查询缓存
List<User> users = query.list();

// 4. 使用二级缓存
@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class User {
    // ...
}

MyBatis优化

xml

<!-- 1. 使用缓存 --><settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

<!-- 2. 使用延迟加载 --><settings>
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

<!-- 3. 使用ResultMap优化映射 --><resultMap id="userMap" type="User">
    <id property="id" column="user_id"/>
    <result property="username" column="user_name"/>
    <result property="email" column="user_email"/>
</resultMap>

<select id="findUserById" resultMap="userMap">
    SELECT user_id, user_name, user_email FROM users WHERE user_id = #{id}
</select>

<!-- 4. 使用动态SQL --><select id="findUsers" resultType="User">
    SELECT * FROM users
    <where>
        <if test="name != null">
            AND name LIKE #{name}
        </if>
        <if test="age != null">
            AND age = #{age}
        </if>
    </where>
</select>

应用级缓存

本地缓存

Guava Cache

java

import com.google.common.cache.*;
import java.util.concurrent.*;

// 创建缓存
LoadingCache<String, User> cache = CacheBuilder.newBuilder()
    .maximumSize(1000) // 最大缓存项数
    .expireAfterWrite(10, TimeUnit.MINUTES) // 写入后过期时间
    .refreshAfterWrite(5, TimeUnit.MINUTES) // 写入后刷新时间
    .concurrencyLevel(4) // 并发级别
    .recordStats() // 记录统计信息
    .removalListener(new RemovalListener<String, User>() {
        @Override
        public void onRemoval(RemovalNotification<String, User> notification) {
            System.out.println("缓存项被移除：" + notification.getKey() + ", 原因：" + notification.getCause());
        }
    })
    .build(new CacheLoader<String, User>() {
        @Override
        public User load(String key) throws Exception {
            // 缓存未命中时加载数据
            return databaseService.findUserById(key);
        }
    });

// 使用缓存
try {
    User user = cache.get("123");
    // 使用user
} catch (ExecutionException e) {
    e.printStackTrace();
}

// 手动放入缓存
cache.put("456", new User("456", "John", "john@example.com"));

// 手动刷新缓存
cache.refresh("123");

// 清除缓存
cache.invalidate("123"); // 清除单个缓存项
cache.invalidateAll(); // 清除所有缓存项

// 获取统计信息
CacheStats stats = cache.stats();
System.out.println("命中率：" + stats.hitRate());
System.out.println("平均加载时间：" + stats.averageLoadPenalty() + "ns");

Caffeine

Caffeine是Java 8+的高性能缓存库，比Guava Cache性能更好。

java

import com.github.benmanes.caffeine.cache.*;
import java.util.concurrent.*;

// 创建缓存
LoadingCache<String, User> cache = Caffeine.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .refreshAfterWrite(5, TimeUnit.MINUTES)
    .recordStats()
    .removalListener((key, value, cause) -> {
        System.out.println("缓存项被移除：" + key + ", 原因：" + cause);
    })
    .build(key -> databaseService.findUserById(key));

// 使用缓存
User user = cache.get("123");

// 手动放入缓存
cache.put("456", new User("456", "John", "john@example.com"));

// 异步加载
AsyncLoadingCache<String, User> asyncCache = Caffeine.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .buildAsync(key -> databaseService.findUserById(key));

// 获取CompletableFuture
CompletableFuture<User> future = asyncCache.get("123");

分布式缓存

Redis缓存

使用Redis作为分布式缓存，可以提高系统的性能和可扩展性。

java

import redis.clients.jedis.*;

// 创建Redis连接池
JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost", 6379);

// 使用Redis
try (Jedis jedis = pool.getResource()) {
    // 设置字符串值
    jedis.set("user:123", "{\"id\":\"123\",\"name\":\"John\",\"email\":\"john@example.com\"}");
    
    // 设置过期时间
    jedis.expire("user:123", 3600);
    
    // 获取值
    String userJson = jedis.get("user:123");
    
    // 使用哈希结构
    jedis.hset("user:456", "id", "456");
    jedis.hset("user:456", "name", "Alice");
    jedis.hset("user:456", "email", "alice@example.com");
    
    // 获取哈希值
    Map<String, String> userMap = jedis.hgetAll("user:456");
    
    // 使用列表
    jedis.lpush("recent_users", "123", "456", "789");
    List<String> recentUsers = jedis.lrange("recent_users", 0, 9);
}

// Spring Cache + Redis
@Configuration
@EnableCaching
public class RedisCacheConfig {
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        
        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
    }
}

// 在Service中使用缓存
@Service
public class UserService {
    @Cacheable(value = "users", key = "#id")
    public User findUserById(String id) {
        // 从数据库查询
        return userRepository.findById(id);
    }
    
    @CachePut(value = "users", key = "#user.id")
    public User updateUser(User user) {
        // 更新数据库
        return userRepository.save(user);
    }
    
    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(String id) {
        // 从数据库删除
        userRepository.deleteById(id);
    }
}

性能监控与分析

JVM监控工具

JConsole

JConsole是JDK自带的图形化监控工具，可以监控JVM的内存使用、线程状态、类加载等信息。

bash

# 启动JConsole
jconsole

VisualVM

VisualVM是一个功能更强大的JVM监控和分析工具，可以进行内存分析、线程分析、性能分析等。

bash

# 启动VisualVM
jvisualvm

JMC (Java Mission Control)

JMC是JDK 7u40及以上版本自带的企业级监控工具，可以进行低开销的性能分析。

bash

# 启动JMC
jmc

性能分析工具

JProfiler

JProfiler是一个商业的Java性能分析工具，可以分析CPU使用情况、内存分配、线程状态、JDBC调用等。

YourKit Java Profiler

YourKit是另一个商业的Java性能分析工具，具有低开销、易用性好等特点。

Async Profiler

Async Profiler是一个开源的低开销Java性能分析工具，可以分析CPU使用、内存分配、锁竞争等。

bash

# 下载Async Profiler
wget https://github.com/jvm-profiling-tools/async-profiler/releases/download/v2.9/async-profiler-2.9-linux-x64.tar.gz
tar -xzf async-profiler-2.9-linux-x64.tar.gz

# 分析CPU使用情况
./profiler.sh -d 30 -f cpu.html <pid>

# 分析内存分配
./profiler.sh -d 30 --alloc -f alloc.html <pid>

# 分析锁竞争
./profiler.sh -d 30 --lock -f lock.html <pid>

日志分析

使用日志分析工具收集和分析应用的性能数据。

java

// 使用SLF4J + Logback记录性能指标
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PerformanceLogger {
    private static final Logger logger = LoggerFactory.getLogger(PerformanceLogger.class);
    
    public static void logMethodExecutionTime(String methodName, long startTime) {
        long endTime = System.currentTimeMillis();
        long executionTime = endTime - startTime;
        
        if (executionTime > 100) { // 只记录执行时间超过100ms的方法
            logger.warn("Method {} executed in {} ms", methodName, executionTime);
        }
    }
}

// 使用示例
public void processOrder(Order order) {
    long startTime = System.currentTimeMillis();
    try {
        // 业务逻辑
        // ...
    } finally {
        PerformanceLogger.logMethodExecutionTime("processOrder", startTime);
    }
}

性能优化最佳实践

编码最佳实践

避免创建不必要的对象：减少内存分配和GC压力
使用基本数据类型：避免自动装箱/拆箱的性能开销
合理使用集合：选择合适的集合类型，设置合适的初始容量
使用StringBuilder进行字符串拼接：避免创建多个String对象
避免在循环中创建对象：将对象创建移到循环外
使用对象池：复用频繁创建的对象
合理使用final关键字：帮助JVM进行优化
避免深拷贝：只在必要时使用深拷贝

架构层面的优化

微服务架构：将单体应用拆分为多个微服务，提高系统的可伸缩性
缓存策略：使用多级缓存（本地缓存+分布式缓存）
数据库优化：读写分离、分库分表、索引优化
异步处理：使用消息队列处理异步任务
负载均衡：使用负载均衡器分发请求
CDN加速：使用CDN分发静态资源
连接池：数据库连接池、HTTP连接池
熔断降级：使用熔断降级机制保护系统

性能测试

在进行性能优化后，必须进行性能测试来验证优化效果。

java

// 使用JMH进行基准测试
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime) // 测量平均执行时间
@OutputTimeUnit(TimeUnit.NANOSECONDS) // 输出时间单位为纳秒
@Warmup(iterations = 5, time = 1) // 预热5轮，每轮1秒
@Measurement(iterations = 10, time = 1) // 测量10轮，每轮1秒
@Fork(2) // 2个独立进程执行测试
@State(Scope.Thread) // 每个线程一个状态实例
public class StringConcatBenchmark {
    private String str1 = "Hello";
    private String str2 = "World";
    
    @Benchmark
    public String stringConcatenation() {
        return str1 + str2;
    }
    
    @Benchmark
    public String stringBuilder() {
        return new StringBuilder(str1).append(str2).toString();
    }
    
    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder()
            .include(StringConcatBenchmark.class.getSimpleName())
            .build();
        new Runner(options).run();
    }
}

总结

Java性能优化是一个持续的过程，需要从多个层面进行考虑，包括JVM调优、代码优化、多线程优化、IO优化、数据库优化等。在进行性能优化时，应该遵循以下步骤：

建立性能基准：测量当前系统的性能指标
识别性能瓶颈：使用性能分析工具找出系统的瓶颈
制定优化方案：根据瓶颈制定有针对性的优化方案
实施优化：应用优化方案
验证优化效果：再次测量性能指标，验证优化效果
持续监控：建立长期的性能监控机制

性能优化不是一蹴而就的，需要在实践中不断积累经验，同时也要注意在性能、功能、可维护性之间找到平衡点。

Java性能优化 ​

性能优化概述 ​

什么是性能优化？ ​

性能优化的目标 ​

性能优化的原则 ​

JVM性能调优 ​

JVM内存模型 ​

JVM内存参数调优 ​

堆内存设置 ​

垃圾收集器选择 ​

GC相关参数 ​

垃圾收集器选择策略 ​

JVM调优案例 ​

Java代码优化 ​

基本数据类型优先 ​

StringBuilder/StringBuffer ​

集合框架优化 ​

集合初始化大小 ​

遍历方式选择 ​

对象池 ​

避免不必要的对象创建 ​

缓存使用 ​

多线程性能优化 ​

线程池优化 ​

线程池参数调优 ​

减少锁竞争 ​

锁粒度优化 ​

使用并发集合 ​

使用读写锁 ​

使用原子类 ​

IO性能优化 ​

NIO vs BIO ​

使用缓冲流 ​

文件操作优化 ​

网络IO优化 ​

使用NIO的Selector ​

使用Netty框架 ​

数据库性能优化 ​

JDBC优化 ​

SQL优化 ​

ORM框架优化 ​

Hibernate优化 ​

MyBatis优化 ​

应用级缓存 ​

本地缓存 ​

Guava Cache ​

Caffeine ​

分布式缓存 ​

Redis缓存 ​

性能监控与分析 ​

JVM监控工具 ​

JConsole ​

VisualVM ​

JMC (Java Mission Control) ​

性能分析工具 ​

JProfiler ​

YourKit Java Profiler ​

Async Profiler ​

日志分析 ​

性能优化最佳实践 ​

编码最佳实践 ​

架构层面的优化 ​

性能测试 ​

总结 ​

Java性能优化

性能优化概述

什么是性能优化？

性能优化的目标

性能优化的原则

JVM性能调优

JVM内存模型

JVM内存参数调优

堆内存设置

垃圾收集器选择

GC相关参数

垃圾收集器选择策略

JVM调优案例

Java代码优化

基本数据类型优先

StringBuilder/StringBuffer

集合框架优化

集合初始化大小

遍历方式选择

对象池

避免不必要的对象创建

缓存使用

多线程性能优化

线程池优化

线程池参数调优

减少锁竞争

锁粒度优化

使用并发集合

使用读写锁

使用原子类

IO性能优化

NIO vs BIO

使用缓冲流

文件操作优化

网络IO优化

使用NIO的Selector

使用Netty框架

数据库性能优化

JDBC优化

SQL优化

ORM框架优化

Hibernate优化

MyBatis优化

应用级缓存

本地缓存

Guava Cache

Caffeine

分布式缓存

Redis缓存

性能监控与分析

JVM监控工具

JConsole

VisualVM

JMC (Java Mission Control)

性能分析工具

JProfiler

YourKit Java Profiler

Async Profiler

日志分析

性能优化最佳实践

编码最佳实践

架构层面的优化

性能测试

总结