性能优化 - 日常开发中的优化项
深夜的告警短信、缓慢滚动的日志、监控面板上刺眼的红色曲线——这些场景背后，往往是未被察觉的效率黑洞。
我们总在架构层面讨论分布式、缓存、分库分表，却忽略了日常编码中那些微小却高频的损耗点。 本文从实战出发，揭秘5个可立即落地的优化技巧，让你从第一行代码开始构建高性能应用。
让优化思维成为肌肉记忆
今日分享几个优化点，很具有代表性，从技术维度上来看，并行化和异步属于并发模型，锁粒度是线程安全核心，集合分配涉及内存管理，启动预处理则是生命周期优化。它们共同构成了高性能系统的骨架。
并行化：释放多核处理器的洪荒之力
代码实现与优化
日常开发中，我们的代码是否都如以下的实现
// 顺序处理耗时任务
for (Item item : itemList) {
process(item); // 单线程阻塞执行
}并行优化的实现
// 利用并行流拆分任务（适用于无状态操作）
itemList.parallelStream().forEach(this::process);
// 或使用CompletableFuture实现精细控制
List<CompletableFuture<Void>> futures = itemList.stream()
.map(item -> CompletableFuture.runAsync(() -> process(item), executor))
.collect(Collectors.toList());
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();关键原则
任务独立性：并行任务间避免共享状态
线程池隔离：CPU密集型 vs IO密集型任务使用不同线程池
代价平衡：避免细粒度任务带来的线程调度开销
异步处理：别让用户为后台操作买单
代码实现与优化
日常开发中的同步阻塞的实现
public Response handleRequest(Request req) {
saveLog(req); // 同步写日志阻塞主线程
sendMQ(req); // 同步消息发送
return doBusinessLogic(req);
}通过异步解耦方案进行优化
@Async("ioThreadPool") // Spring异步注解
public void asyncSaveLog(Request req) { ... }
public Response handleRequest(Request req) {
asyncSaveLog(req); // 异步日志
mqTemplate.asyncSend(req); // 消息队列异步发送
return doBusinessLogic(req); // 主线程快速返回
}实现方案
异步解耦的方案各种各样，例如
Spring @Async + 自定义线程池
MQ解耦（RabbitMQ/Kafka）
Reactor响应式编程
我们选择适合当前业务场景的即可
锁粒度控制：并发场景的精细手术刀
代码实现与优化
1、使用 synchronized 互斥锁
@RequestMapping("/doSave")
public synchronized void doSave(String path,String filterUrl){
// 创建文件夹
mkdir();
// 上传文件
uploadFile(filterUrl);
// 发送消息
sendMessage(filterUrl);
}减少锁粒度
@RequestMapping("/doSave")
public void doSave(String path,String filterUrl){
// 创建文件夹
synchronized (this){
if(!existPath(path)){
mkdir();
}
}
// 上传文件
uploadFile(filterUrl);
// 发送消息
sendMessage(filterUrl);
}2、由于我们一般都是多台机器所以我们需要分布式锁
@RequestMapping("/doSave")
public void doSave(String path,String filterUrl) {
String lockKey = "mkdir-lock";
RLock lock = redissonClient.getLock(lockKey);
if(lock.tryLock()) {
try {
//创建文件夹
mkdir();
// 上传文件
uploadFile(filterUrl);
// 发送消息
sendMessage(filterUrl);
} finally {
lock.unlock();
}
}
}减少锁粒度
@RequestMapping("/doSave")
public void doSave(String path,String filterUrl) {
String lockKey = "mkdir-lock";
RLock lock = redissonClient.getLock(lockKey);
if(lock.tryLock()) {
try {
//创建文件夹
mkdir();
} finally {
lock.unlock();
}
}else{
return;
}
// 上传文件
uploadFile(filterUrl);
// 发送消息
sendMessage(filterUrl);
}3、粗粒度锁的性能瓶颈
public class CachePool {
private final Map<String, Object> cache = new HashMap<>();
private final ReentrantLock lock = new ReentrantLock(); // 全局锁
public void update(String key, Object value) {
lock.lock(); // 更新任何key都阻塞所有读写
try { cache.put(key, value); }
finally { lock.unlock(); }
}
}细粒度锁优化
public class CachePool {
private final Map<String, Object> cache = new ConcurrentHashMap<>();
// 使用分段锁（JDK8+推荐直接用ConcurrentHashMap）
private final Striped<Lock> keyLocks = Striped.lock(32); // Guava分段锁
public void update(String key, Object value) {
Lock keyLock = keyLocks.get(key);
keyLock.lock(); // 只锁定当前key的槽位
try { cache.put(key, value); }
finally { keyLock.unlock(); }
}
}
集合空间分配：向动态扩容说“不”
代码实现与优化
如何创建一个集合，这还不简单，很快我们就写出下面代码
List<String> lists = Lists.newArrayList();
如果说，要往里面插入 1000000 个元素，有没有更好的方式？
public class ArrayListTest {
public static void main(String[] args) {
List<String> userNames = new ArrayList<>();
Long beginTime = System.currentTimeMillis();
for(int i = 0;i < 1000000;i++){
userNames.add("天涯" + i);
}
long endTime = System.currentTimeMillis();
System.out.println("1000000 次插入List花费的时间：" + (endTime - beginTime));
List<String> userNames2 = new ArrayList<>(1000000);
Long beginTime2 = System.currentTimeMillis();
for(int i = 0;i < 1000000;i++){
userNames2.add("天涯" + i);
}
long endTime2 = System.currentTimeMillis();
System.out.println("1000000 次插入List花费的时间：" + (endTime2 - beginTime2));
}
}ArrayList 初始大小是 10，超过阈值会按 1.5 倍大小扩容，涉及老集合到新集合的数据拷贝，浪费性能。了解其底层，可以知道 频繁扩容 才是罪魁祸首，通过一下测试数据可以看出性能差距
预分配空间优化
如果我们预先知道集合要存储多少元素，初始化集合时尽量指定大小，尤其是容量较大的集合。
// ArrayList预分配
List<User> userList = new ArrayList<>(100_000);
// HashMap避免哈希冲突
Map<String, User> userMap = new HashMap<>(100_000, 0.75f);
// Guava集合工厂
Set<String> typeSet = Sets.newHashSetWithExpectedSize(50);项目启动预处理：赢在起跑线上
有很多业务的计算逻辑比较复杂，比如页面要展示一个网站的 PV，教育网站中用户学习时间等等，
如果在用户访问接口的瞬间触发计算逻辑，而这些逻辑计算的耗时通常比较长，很难满足用户的实时性要求。
一般我们都是提前计算，然后将算好的数据预热到缓存中，接口访问时，只需要读缓存即可
如果业务实时性没有那么高，可以通过定时，晚上进行处理计算处理。
还有一种是项目启动时初始化的动作，例如加载字典到缓存中，可以通过实现 CommandLineRunner 或 ApplicationRunner 接口
预热方案实践
@Component
public class PreloadRunner implements CommandLineRunner {
@Autowired
private CacheService cacheService;
@Autowired
private DbConnectionPool pool;
@Override
public void run(String... args) {
// 1. 提前初始化连接池
pool.warmUp(10);
// 2. 热点数据缓存预热
cacheService.preloadHotData();
// 3. 类加载触发（如日志配置）
LoggerFactory.getLogger(this.getClass());
}
}