服务架构性能优化大全（附Java代码实现）

一、缓存

核心思想：将高频访问数据存储在高速存储中，减少慢速存储（如数据库）访问
场景：读多写少的数据（用户信息、配置数据）
Java实现：使用Caffeine缓存

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

public class CacheExample {
    private static Cache<String, Object> cache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();

    // 获取数据（缓存未命中时从DB加载）
    public Object getData(String key) {
        return cache.get(key, k -> fetchFromDatabase(k));
    }

    private Object fetchFromDatabase(String key) {
        // 模拟数据库查询
        return "Data for " + key;
    }

    // 更新缓存
    public void updateData(String key, Object value) {
        writeToDatabase(key, value);
        cache.put(key, value);
    }
}

二、并行化处理

核心思想：将任务分解为子任务并行执行，利用多核CPU
场景：大数据处理、批量计算
Java实现：使用ForkJoinPool

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ParallelSum extends RecursiveTask<Long> {
    private final long[] numbers;
    private final int start, end;
    private static final int THRESHOLD = 10_000;

    public ParallelSum(long[] numbers, int start, int end) {
        this.numbers = numbers;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        int length = end - start;
        if (length <= THRESHOLD) {
            return sequentialSum();
        }
        ParallelSum leftTask = new ParallelSum(numbers, start, start + length/2);
        ParallelSum rightTask = new ParallelSum(numbers, start + length/2, end);
        leftTask.fork();  // 异步执行
        return rightTask.compute() + leftTask.join();
    }

    private long sequentialSum() {
        long sum = 0;
        for (int i = start; i < end; i++) {
            sum += numbers[i];
        }
        return sum;
    }

    public static void main(String[] args) {
        long[] numbers = new long[20_000_000];
        // 初始化数组...
        ForkJoinPool pool = new ForkJoinPool();
        Long sum = pool.invoke(new ParallelSum(numbers, 0, numbers.length));
    }
}

三、批量化处理

核心思想：将零散操作合并为批量操作，减少I/O次数
场景：数据库写入、消息发送
Java实现：批量数据库插入

// 使用JDBC批处理
public class BatchInsert {
    public void batchInsert(List<User> users) throws SQLException {
        try (Connection conn = dataSource.getConnection();
             PreparedStatement ps = conn.prepareStatement(
                 "INSERT INTO users (id, name) VALUES (?, ?)")) {
            
            conn.setAutoCommit(false);  // 关闭自动提交
            
            for (User user : users) {
                ps.setInt(1, user.getId());
                ps.setString(2, user.getName());
                ps.addBatch();  // 加入批处理
            }
            
            ps.executeBatch();  // 批量执行
            conn.commit();      // 手动提交
        }
    }
}

// 使用MyBatis批处理
<insert id="batchInsert" parameterType="list">
    INSERT INTO users (id, name) VALUES
    <foreach item="user" collection="list" separator=",">
        (#{user.id}, #{user.name})
    </foreach>
</insert>

四、数据压缩

核心思想：减小网络传输和存储的数据体积
场景：API响应、消息队列
Java实现：GZIP压缩

import java.io.*;
import java.util.zip.GZIPOutputStream;

public class CompressionUtils {
    public static byte[] compress(String data) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try (GZIPOutputStream gzip = new GZIPOutputStream(bos)) {
            gzip.write(data.getBytes(StandardCharsets.UTF_8));
        }
        return bos.toByteArray();
    }

    // HTTP响应压缩示例（Spring Boot）
    @GetMapping("/data")
    public ResponseEntity<byte[]> getLargeData() throws IOException {
        String largeData = fetchDataFromSource();
        return ResponseEntity.ok()
                .header("Content-Encoding", "gzip")
                .body(compress(largeData));
    }
}

五、无锁化

核心思想：避免线程阻塞，使用CAS（Compare-And-Swap）操作
场景：计数器、状态标志
Java实现：AtomicLong vs Synchronized

// 无锁实现
public class LockFreeCounter {
    private final AtomicLong counter = new AtomicLong(0);
    
    public void increment() {
        counter.incrementAndGet();
    }
    
    public long getCount() {
        return counter.get();
    }
}

// 对比加锁实现
public class LockedCounter {
    private long counter = 0;
    
    public synchronized void increment() {
        counter++;
    }
    
    public synchronized long getCount() {
        return counter;
    }
}

六、顺序写

核心思想：磁盘顺序写入速度远高于随机写入
场景：日志存储、消息队列（Kafka）
Java实现：顺序写文件

public class SequentialWriter {
    private final FileChannel channel;
    
    public SequentialWriter(String filePath) throws IOException {
        RandomAccessFile file = new RandomAccessFile(filePath, "rw");
        this.channel = file.getChannel();
    }
    
    public void append(byte[] data) throws IOException {
        channel.write(ByteBuffer.wrap(data), channel.size());
    }
    
    // Kafka日志追加伪代码
    public void appendToPartition(TopicPartition partition, byte[] data) {
        File logFile = getPartitionLogFile(partition);  // 获取分区对应文件
        writeSequentially(logFile, data);               // 顺序追加
    }
}

七、分片化

核心思想：将大数据集分割为独立分区（Shard）分散压力
场景：数据库分库分表、分布式缓存
Java实现：分片路由

public class ShardManager {
    private List<DataSource> shards; // 分片数据源列表

    // 根据分片键路由
    public DataSource getShard(String shardKey) {
        int shardIndex = Math.abs(shardKey.hashCode()) % shards.size();
        return shards.get(shardIndex);
    }

    // 分片写入示例
    public void insertUser(User user) {
        DataSource shard = getShard(user.getUserId());
        try (Connection conn = shard.getConnection()) {
            // 在分片DB执行插入
        }
    }
}

八、避免请求

核心思想：减少不必要的网络交互
实现方案：

1. 客户端缓存：HTTP缓存头（Cache-Control）
2. 预测执行：预先加载可能使用的数据
3. 空结果缓存：缓存查询无结果的响应
4. 布隆过滤器：快速判断数据是否存在

Java实现：布隆过滤器（Guava）

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;

public class BloomFilterExample {
    private BloomFilter<String> bloomFilter = BloomFilter.create(
            Funnels.stringFunnel(), 
            100_000, 
            0.01  // 误判率1%
    );

    public void processRequest(String key) {
        if (!bloomFilter.mightContain(key)) {
            // 肯定不存在，直接返回
            return;
        }
        // 可能存在，继续查询DB
        fetchFromDB(key);
    }

    public void addKey(String key) {
        bloomFilter.put(key);
        writeToDB(key);
    }
}

九、池化

核心思想：复用昂贵资源（线程/连接），避免重复创建
场景：数据库连接、线程管理
Java实现：HikariCP连接池

// 配置连接池
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost/db");
config.setUsername("user");
config.setPassword("password");
config.setMaximumPoolSize(20);  // 最大连接数

HikariDataSource dataSource = new HikariDataSource(config);

// 获取连接
try (Connection conn = dataSource.getConnection()) {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT * FROM users");
    // 处理结果...
}

十、异步处理

核心思想：非阻塞调用，资源释放给其他任务
场景：I/O密集型操作、通知类逻辑
Java实现：CompletableFuture

public class AsyncProcessor {
    private final ExecutorService executor = Executors.newFixedThreadPool(4);

    public CompletableFuture<Void> processAsync() {
        return CompletableFuture.runAsync(() -> {
            // 异步执行耗时操作
            heavyCalculation();
        }, executor);
    }

    // 链式调用
    public void pipeline() {
        CompletableFuture.supplyAsync(this::fetchData, executor)
                .thenApply(this::transformData)
                .thenAccept(this::sendNotification)
                .exceptionally(ex -> {
                    System.err.println("Error: " + ex.getMessage());
                    return null;
                });
    }
}

十一、总结

综合建议：

1. 优先使用异步和非阻塞IO（如Netty）
2. 80%性能问题可通过缓存+批量化解决
3. 分布式场景采用分片化+无状态设计
4. 监控先行：量化优化效果（Latency/Throughput/Error率）
5. 避免过度优化：复杂度与收益需平衡