在Java应用运行过程中，对象的创建和销毁会占用JVM的堆内存资源，频繁的GC操作也会影响应用的响应速度，通过合理的对象缓存与复用机制，可以有效降低这些开销，提升系统整体性能。
对象缓存与复用的核心原理
对象缓存的本质是将已经创建完成、暂时不再使用的对象存储到特定的容器中，当后续需要同类型对象时，优先从容器中获取已有对象，而不是重新创建新的实例。对象复用则是让同一个对象在多个业务场景中重复使用，避免重复初始化带来的资源浪费。
这种方式的核心优势在于减少对象创建的次数，降低JVM堆内存的分配压力，同时减少垃圾回收的触发频率，尤其适合那些创建成本高、生命周期短但使用频繁的对象。
手动实现简单对象缓存
对于简单的场景，我们可以使用Map容器手动实现对象缓存，以下是一个基础的实现示例：
import java.util.HashMap;
import java.util.Map;
public class SimpleObjectCache<K, V> {
// 缓存容器，存储键值对形式的缓存对象
private final Map<K, V> cacheMap = new HashMap<>();
// 缓存最大容量，避免内存溢出
private final int maxSize;
public SimpleObjectCache(int maxSize) {
this.maxSize = maxSize;
}
/**
* 从缓存中获取对象，如果不存在则返回null
*/
public V get(K key) {
return cacheMap.get(key);
}
/**
* 向缓存中存入对象，超过最大容量时移除最早存入的对象
*/
public void put(K key, V value) {
if (cacheMap.size() >= maxSize) {
// 简单处理：移除第一个键，实际场景可使用LRU等策略
K firstKey = cacheMap.keySet().iterator().next();
cacheMap.remove(firstKey);
}
cacheMap.put(key, value);
}
/**
* 清空缓存
*/
public void clear() {
cacheMap.clear();
}
}
上述实现适合缓存少量、无状态或者状态可重置的对象，对于需要复杂管理策略的场景，手动实现会显得不够灵活。
使用对象池实现对象复用
对象池是对象复用的常用实现方式，它会预先创建一定数量的对象放在池中，使用时从池中获取，使用完毕后归还到池中，而不是直接销毁。以下是一个简单的对象池实现示例：
import java.util.Queue;
import java.util.LinkedList;
public class SimpleObjectPool<T> {
// 存储空闲对象的队列
private final Queue<T> idleObjects = new LinkedList<>();
// 存储所有已创建对象的队列，用于统计和管理
private final Queue<T> allObjects = new LinkedList<>();
// 对象池最大容量
private final int maxSize;
// 对象工厂，用于创建新对象
private final ObjectFactory<T> factory;
public SimpleObjectPool(int maxSize, ObjectFactory<T> factory) {
this.maxSize = maxSize;
this.factory = factory;
}
/**
* 从对象池获取对象
*/
public T borrowObject() {
T obj;
if (idleObjects.isEmpty()) {
// 空闲对象不足，创建新对象
if (allObjects.size() < maxSize) {
obj = factory.createObject();
allObjects.add(obj);
} else {
// 达到最大容量，暂时返回null，实际场景可阻塞等待
return null;
}
} else {
obj = idleObjects.poll();
}
return obj;
}
/**
* 归还对象到对象池
*/
public void returnObject(T obj) {
// 重置对象状态，避免脏数据影响下次使用
if (obj instanceof Resettable) {
((Resettable) obj).reset();
}
idleObjects.add(obj);
}
/**
* 对象工厂接口
*/
public interface ObjectFactory<T> {
T createObject();
}
/**
* 可重置接口，需要复用的对象可以实现该接口
*/
public interface Resettable {
void reset();
}
}
使用对象池时，需要注意对象的状态重置，避免上一次使用的残留数据影响后续业务逻辑，同时要根据业务场景合理设置池的最大容量，避免内存浪费或者对象不足的问题。
借助第三方工具实现缓存与复用
在实际的企业级开发中，我们通常会使用成熟的第三方工具来实现对象缓存与复用，常用的工具包括：
- Caffeine：高性能的本地缓存库，支持多种缓存过期策略、容量限制，适合本地对象缓存场景
- Apache Commons Pool：通用的对象池实现框架，提供了完善的对象池管理功能，支持自定义对象工厂和池配置
- Guava Cache：Google提供的本地缓存工具，使用简单，适合中小规模的缓存需求
以下是使用Caffeine实现对象缓存的示例：
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.util.concurrent.TimeUnit;
public class CaffeineCacheDemo {
public static void main(String[] args) {
// 创建缓存实例，设置最大容量为100，写入后5分钟过期
Cache<String, Object> cache = Caffeine.newBuilder()
.maximumSize(100)
.expireAfterWrite(5, TimeUnit.MINUTES)
.build();
// 存入缓存
cache.put("user_1", new Object());
// 获取缓存，不存在则返回null
Object obj = cache.getIfPresent("user_1");
System.out.println(obj != null ? "缓存命中" : "缓存未命中");
}
}
不同场景的选择建议
在选择对象缓存与复用的实现方式时，需要结合具体业务场景：
| 场景 | 推荐方案 | 适用说明 |
|---|---|---|
| 少量简单对象缓存 | 手动Map缓存 | 实现简单，无额外依赖，适合小范围使用 |
| 频繁创建销毁的高成本对象 | 自定义对象池/Apache Commons Pool | 有效复用对象，降低创建成本 |
| 需要过期策略、容量控制的本地缓存 | Caffeine/Guava Cache | 功能完善，性能优异，减少重复开发 |
需要注意的是，不是所有对象都适合缓存与复用，对于无状态、创建成本极低的对象，缓存反而会带来额外的管理开销，反而降低性能。开发者需要根据对象的创建成本、使用频率、生命周期等因素综合判断，选择合适的优化方案。