• 1. 并行处理
• 2. 最小化事务范围
• 3. 缓存
• 4. 合理使用线程池
• 5. 服务预热
• 6. 缓存对齐
• 7. 减少对象的产生
• 8. 并发处理
• 9. 异步
• 10. for循环优化
• 11. 减少网络传输的体积
• 12. 减少服务之间的依赖

1. 并行处理：利用CompletableFuture加速IO密集型操作

java

// 并行查询用户订单和地址信息
public CompletableFuture<ApiResponse> getUserProfile(Long userId) {
    CompletableFuture<Order> orderFuture = CompletableFuture.supplyAsync(() -> 
        orderService.getUserOrder(userId), ioThreadPool);
    
    CompletableFuture<Address> addressFuture = CompletableFuture.supplyAsync(() -> 
        addressService.getUserAddress(userId), ioThreadPool);

    return orderFuture.thenCombineAsync(addressFuture, (order, address) -> 
        new ApiResponse(order, address), cpuThreadPool);
}

效果：将原本串行100ms的IO操作压缩至50ms内完成

2. 最小化事务范围：缩短数据库锁持有时间

java

@Transactional
public void updateOrder(Order order) {
    // 非数据库操作前置处理
    validateOrder(order); 
    processImages(order); // 耗时操作移出事务
    
    // 事务内仅保留数据库操作
    orderDao.update(order); 
    auditDao.logUpdate(order.getId());
} // 事务在此提交，释放锁

3. 缓存：Guava实现本地缓存

java

LoadingCache<String, Product> productCache = CacheBuilder.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(new CacheLoader<>() {
        @Override
        public Product load(String key) {
            return productDao.getById(key); // 缓存击穿时自动加载
        }
    });

// 使用示例
Product p = productCache.get("P1001"); 

4. 合理配置线程池：定制IO密集型线程池

java

ThreadPoolExecutor ioThreadPool = new ThreadPoolExecutor(
    50, // 根据QPS测算
    100,
    30L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000),
    new ThreadFactoryBuilder().setNameFormat("io-pool-%d").build(),
    new ThreadPoolExecutor.CallerRunsPolicy() // 饱和策略
);

5. 服务预热：JVM类加载优化

java

// 服务启动时预加载核心类
@PostConstruct
public void preheat() {
    IntStream.range(1, 1000).parallel().forEach(i -> {
        cache.getIfPresent("KEY_" + i); // 触发缓存加载
        new ComplexObject(); // 初始化高频对象
    });
}

6. 缓存对齐：分布式缓存刷新策略

java

// 使用Redis发布订阅同步集群节点缓存
@Autowired private RedisTemplate<String, Object> redisTemplate;

public void updateProduct(Product product) {
    productDao.update(product);
    localCache.invalidate(product.getId());
    
    // 发布缓存失效通知
    redisTemplate.convertAndSend("cache_channel", 
        new CacheMessage("product", product.getId()));
}

7. 减少对象产生：重用可变对象

java

// 使用ThreadLocal复用StringBuilder
private static final ThreadLocal<StringBuilder> threadLocalBuilder = 
    ThreadLocal.withInitial(() -> new StringBuilder(512));

public String buildJson(List<Item> items) {
    StringBuilder sb = threadLocalBuilder.get();
    sb.setLength(0); // 清空内容重用对象
    
    items.forEach(item -> sb.append(item.toJsonString()));
    return sb.toString();
}

8. 并发处理：分段锁优化库存扣减

java

// 使用LongAdder替代AtomicLong
private final LongAdder[] segmentCounters = new LongAdder[32]; 

public void deductStock(String itemId, int count) {
    int segment = itemId.hashCode() & 31; // 32段位桶
    segmentCounters[segment].add(-count); // 无锁并发更新
}

9. 异步：@Async实现非阻塞日志

java

@Service
public class LogService {
    @Async("logThreadPool") // 指定异步线程池
    public void asyncWriteLog(Log log) {
        logDao.insert(log); // 耗时IO操作
    }
}

// 控制器调用
logService.asyncWriteLog(new Log("/api/user", params)); // 立即返回

10. for循环优化：避免在循环内执行IO

java

// 优化前（N+1查询问题）
userIds.forEach(id -> userDao.getDetail(id)); 

// 优化后：批量查询
List<Long> ids = Arrays.asList(1001L, 1002L, 1003L);
Map<Long, UserDetail> details = userDao.batchGetDetails(ids); // 单次查询

11. 减少网络体积：Protobuf替代JSON

java

// 配置Protobuf消息转换器
@Bean
ProtobufHttpMessageConverter protobufConverter() {
    return new ProtobufHttpMessageConverter();
}

// 控制器返回Protobuf对象
@GetMapping("/users")
UserProto.UsersResponse getUsers() {
    return UserProto.UsersResponse.newBuilder()
        .addAllUsers(userList).build(); // 体积比JSON小60%
}

12. 减少服务依赖：客户端熔断降级

java

// 使用Resilience4j熔断器
@CircuitBreaker(name = "paymentService", fallbackMethod = "fallback")
public PaymentResult callPayment(PaymentRequest req) {
    return paymentClient.process(req); // 远程调用
}

// 降级方法
private PaymentResult fallback(PaymentRequest req, Exception e) {
    return new PaymentResult(500, "支付服务降级处理"); 
}

关键优化效果对比

最佳实践建议：

IO密集型操作优先考虑异步/并行

锁竞争场景使用分段锁或CAS替代

高频调用数据必须缓存+失效策略

网络传输采用二进制协议

过载保护需实现熔断降级机制

13. 零拷贝技术：文件传输优化

java

// 使用FileChannel传输大文件
@GetMapping("/download")
public void downloadFile(HttpServletResponse response) throws IOException {
    try (FileChannel channel = new FileInputStream("largefile.zip").getChannel()) {
        response.setHeader("Content-Disposition", "attachment; filename=largefile.zip");
        ServletOutputStream out = response.getOutputStream();
        FileChannel outChannel = Channels.newChannel(out);
        
        // 零拷贝传输（避免内核缓冲区拷贝）
        channel.transferTo(0, channel.size(), outChannel);
    }
}

14. 预编译语句：减少SQL解析开销

java

// 使用PreparedStatement缓存
public class OrderDao {
    private static final Map<String, PreparedStatement> stmtCache = new ConcurrentHashMap<>();
    
    public List<Order> getOrders(Date start, Date end) throws SQLException {
        String sql = "SELECT * FROM orders WHERE create_time BETWEEN ? AND ?";
        PreparedStatement stmt = stmtCache.computeIfAbsent(sql, k -> 
            connection.prepareStatement(k));
        
        stmt.setDate(1, new java.sql.Date(start.getTime()));
        stmt.setDate(2, new java.sql.Date(end.getTime()));
        return stmt.executeQuery();
    }
}

15. 位图压缩：海量布尔值存储

java

// 使用BitSet替代boolean数组
public class FeatureFlags {
    private static final BitSet flags = new BitSet(10_000_000);
    
    // 内存占用从10MB降至1.25MB
    public void setEnabled(int userId, boolean enabled) {
        flags.set(userId, enabled);
    }
    
    public boolean isEnabled(int userId) {
        return flags.get(userId);
    }
}

16. 堆外内存：避免GC停顿

java

// 使用DirectByteBuffer处理大内存
public class ImageProcessor {
    private ByteBuffer buffer = ByteBuffer.allocateDirect(1024 * 1024 * 100); // 100MB堆外内存
    
    public void processImage(byte[] imageData) {
        buffer.put(imageData);
        buffer.flip();
        
        // 图像处理逻辑（避免GC影响）
        while(buffer.hasRemaining()) {
            // 每个像素处理...
        }
    }
}

17. 数据分片：水平切分负载

java

// 按用户ID分片路由
public class ShardingRouter {
    private static final int SHARDS = 16;
    
    public DataSource getDataSource(long userId) {
        int shardId = (int) (userId % SHARDS);
        return dataSourceMap.get(shardId);
    }
}

// 分片查询
public User getUser(long userId) {
    DataSource ds = shardingRouter.getDataSource(userId);
    return ds.query("SELECT * FROM user_"+ (userId%16) +" WHERE id=?", userId);
}

18. 列式存储：优化分析型查询

java

// 使用列式数据结构
public class ColumnStore {
    // 列存储代替行存储
    private long[] ids = new long[100_000];
    private String[] names = new String[100_000];
    private double[] balances = new double[100_000];
    
    public double getTotalBalance() {
        double total = 0;
        for (int i = 0; i < balances.length; i++) {
            total += balances[i]; // CPU缓存友好
        }
        return total;
    }
}

19. 写时复制：无锁读优化

java

// 使用CopyOnWriteArrayList替代同步List
public class PriceBoard {
    private final CopyOnWriteArrayList<PriceListener> listeners = new CopyOnWriteArrayList<>();
    
    // 高频读取无锁（每秒百万次）
    public void publishPrice(double price) {
        for (PriceListener listener : listeners) { // 快照遍历
            listener.onUpdate(price);
        }
    }
    
    // 低频更新
    public void addListener(PriceListener listener) {
        listeners.add(listener);
    }
}

20. SIMD优化：利用CPU向量指令

java

// 使用Panama Vector API (JDK17+)
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_256;

public float[] vectorAdd(float[] a, float[] b) {
    float[] c = new float[a.length];
    for (int i = 0; i < a.length; i += SPECIES.length()) {
        FloatVector va = FloatVector.fromArray(SPECIES, a, i);
        FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
        va.add(vb).intoArray(c, i); // 单指令处理8个float
    }
    return c;
}

21. 内存布局优化：减少缓存行伪共享

java

// 使用@Contended避免伪共享
public class Counter {
    @jdk.internal.vm.annotation.Contended
    private volatile long count1 = 0;
    
    @jdk.internal.vm.annotation.Contended
    private volatile long count2 = 0;
}

22. 计算下推：数据库过滤前置

java

// 使用JPA Specification实现条件组合
public List<Order> queryOrders(OrderQuery query) {
    return orderRepo.findAll((root, criteria, cb) -> {
        List<Predicate> predicates = new ArrayList<>();
        if (query.getStatus() != null) {
            predicates.add(cb.equal(root.get("status"), query.getStatus()));
        }
        if (query.getMinAmount() != null) {
            predicates.add(cb.ge(root.get("amount"), query.getMinAmount()));
        }
        return cb.and(predicates.toArray(new Predicate[0]));
    });
}

23. 梯度限流：动态流量控制

java

// 使用Sentinel实现QPS阶梯限流
public void initFlowRule() {
    List<FlowRule> rules = new ArrayList<>();
    FlowRule rule = new FlowRule("queryOrders");
    
    // 根据系统负载动态调整
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    rule.setCount(1000); // 正常阈值
    rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP); // 预热模式
    rule.setWarmUpPeriodSec(10); // 冷启动时间
    
    rules.add(rule);
    FlowRuleManager.loadRules(rules);
}

24. 索引压缩：位图索引加速查询

java

// 使用RoaringBitmap实现高效索引
public class UserIndex {
    private final Map<String, RoaringBitmap> index = new HashMap<>();
    
    public void addUser(String city, long userId) {
        index.computeIfAbsent(city, k -> new RoaringBitmap())
             .add((int)userId);
    }
    
    // 毫秒级求交集：北京+90后
    public RoaringBitmap query(String city, int birthYear) {
        return RoaringBitmap.and(
            index.getOrDefault(city, new RoaringBitmap()),
            birthIndex.getOrDefault(birthYear, new RoaringBitmap())
        );
    }
}

性能优化层次金字塔

图表

代码

性能陷阱规避清单

1. 缓存穿透：布隆过滤器拦截非法查询
2. java
3. if(!bloomFilter.mightContain(key)) return null;
4. 缓存雪崩：随机过期时间
5. java
6. cache.set(key, value, 300 + random.nextInt(30)); // 300-330s随机
7. 线程饥饿：隔离CPU/IO线程池
8. 伪共享：关键字段添加缓存行填充
9. 过早优化：优先基于性能分析结果

黄金法则：

优先优化调用次数最多的10%代码

优化后必须用JMH验证效果

生产环境开启全链路监控（如SkyWalking）

性能指标需包含P99和最大延迟