一招MAX降低10倍，现在它是我的了| 京东到家门店系统OHC本地缓存优化实战

• 背景
• 初识此物心已惊-OHC初识
• 习得技能心自安-OHC使用
• 剖析根源见真谛-OHC原理
• 总结

<!--OHC相关--><dependency>  <groupId>org.caffinitas.ohc</groupId>  <artifactId>ohc-core</artifactId>  <version>0.7.4</version></dependency>
<!--OHC 存储的是二进制数组，所以需要实现OHC序列化接口，将缓存数据与二进制数组之间序列化和反序列化--><!--这里使用的是protostuff，当然也可以使用kryo、Hession等，通过压测验证选择适合的--><dependency>  <groupId>io.protostuff</groupId>  <artifactId>protostuff-core</artifactId>  <version>1.6.0</version></dependency><dependency>  <groupId>io.protostuff</groupId>  <artifactId>protostuff-runtime</artifactId>  <version>1.6.0</version></dependency>

OHCache<String, XxxxInfo> basicStoreInfoCache = OHCacheBuilder.<String, XxxxInfo>newBuilder()                    .keySerializer(new OhcStringSerializer()) //key的序列化器                    .valueSerializer(new OhcProtostuffXxxxInfoSerializer()) //value的序列化器                    .segmentCount(512) // 分段数量 默认=2*CPU核数                    .hashTableSize(100000)// 哈希表大小 默认=8192                    .capacity(1024 * 1024 * 1024) //缓存容量 单位B 默认64MB                    .eviction(Eviction.LRU) // 淘汰策略 可选LRU\W_TINY_LFU\NONE                    .timeouts(false) //不使用过期时间，根据业务自己选择                    .build();

//key-String 序列化器，这里直接复用OCH源码中测试用例的String序列化器public class OhcStringSerializer implements CacheSerializer<String> {
    @Override    public int serializedSize(String value) {        return writeUTFLen(value);    }
    @Override    public void serialize(String value, ByteBuffer buf) {        // 得到字符串对象UTF-8编码的字节数组        byte[] bytes = value.getBytes(Charsets.UTF_8);        buf.put((byte) ((bytes.length >>> 8) & 0xFF));        buf.put((byte) ((bytes.length >>> 0) & 0xFF));        buf.put(bytes);    }

    @Override    public String deserialize(ByteBuffer buf) {        int length = (((buf.get() & 0xff) << 8) + ((buf.get() & 0xff) << 0));        byte[] bytes = new byte[length];        buf.get(bytes);        return new String(bytes, Charsets.UTF_8);    }    static int writeUTFLen(String str) {        int strlen = str.length();        int utflen = 0;        int c;
        for (int i = 0; i < strlen; i++) {            c = str.charAt(i);            if ((c >= 0x0001) && (c <= 0x007F)){                utflen++;}            else if (c > 0x07FF){                utflen += 3;}            else{                utflen += 2;            }        }
        if (utflen > 65535) {            throw new RuntimeException("encoded string too long: " + utflen + " bytes");        }        return utflen + 2;    }}

//value-自定义对象序列化器，这里用Protostuff实现,可以自己选择使用kryo、Hession等实现public class OhcProtostuffXxxxInfoSerializer implements CacheSerializer<XxxxInfo> {
    /**     * 将缓存数据序列化到 ByteBuffer 中，ByteBuffer是OHC管理的堆外内存区域的映射。     */    @Override    public void serialize(XxxxInfo t, ByteBuffer byteBuffer) {        byteBuffer.put(ProtostuffUtils.serialize(t));    }    /**     * 对堆外缓存的数据进行反序列化     */    @Override    public XxxxInfo deserialize(ByteBuffer byteBuffer) {        byte[] bytes = new byte[byteBuffer.remaining()];        byteBuffer.get(bytes);        return ProtostuffUtils.deserialize(bytes, XxxxInfo.class);    }
    /**     * 计算字序列化后占用的空间     */    @Override    public int serializedSize(XxxxInfo t) {        return ProtostuffUtils.serialize(t).length;    }}

public class ProtostuffUtils {
    /**     * 避免每次序列化都重新申请Buffer空间，提升性能     */    private static final FastThreadLocal<LinkedBuffer> bufferPool = new FastThreadLocal<LinkedBuffer>() {        @Override        protected LinkedBuffer initialValue() throws Exception {            return LinkedBuffer.allocate(4 * 2 * LinkedBuffer.DEFAULT_BUFFER_SIZE);        }    };
    /**     * 缓存Schema     */    private static Map<Class<?>, Schema<?>> schemaCache = new ConcurrentHashMap<>();
    /**     * 序列化方法，把指定对象序列化成字节数组     */    @SuppressWarnings("unchecked")    public static <T> byte[] serialize(T obj) {        Class<T> clazz = (Class<T>) obj.getClass();        Schema<T> schema = getSchema(clazz);        byte[] data;        LinkedBuffer linkedBuffer = null;        try {            linkedBuffer = bufferPool.get();            data = ProtostuffIOUtil.toByteArray(obj, schema, linkedBuffer);        } finally {            if (Objects.nonNull(linkedBuffer)) {                linkedBuffer.clear();            }        }
        return data;    }
    /**     * 反序列化方法，将字节数组反序列化成指定Class类型     */    public static <T> T deserialize(byte[] data, Class<T> clazz) {        Schema<T> schema = getSchema(clazz);        T obj = schema.newMessage();        ProtostuffIOUtil.mergeFrom(data, obj, schema);        return obj;    }
    @SuppressWarnings("unchecked")    private static <T> Schema<T> getSchema(Class<T> clazz) {        Schema<T> schema = (Schema<T>) schemaCache.get(clazz);        if (Objects.isNull(schema)) {            schema = RuntimeSchema.getSchema(clazz);            if (Objects.nonNull(schema)) {                schemaCache.put(clazz, schema);            }        }
        return schema;    }}