当前位置：首页 > article >正文

【缓存策略】你知道 Write Around（缓存绕过写）这个缓存策略吗？

article 2024/11/14 12:13:31

👉博主介绍：博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：个人社区
💞 个人主页：个人主页
🙉 专栏地址： ✅ Java 中级
🙉八股文专题：剑指大厂，手撕 Java 八股文

在这里插入图片描述

文章目录

- - 1. 缓存策略 Write Around 是什么？
  - 2. 缓存策略 Write Around 的应用场景
  - 3. 缓存策略 Write Around 的优缺点
  - 4. 用 Java 模拟使用 Write Around 策略
  - - 1. 创建缓存类
    - 2. 创建后端存储类
    - 3. 使用缓存

1. 缓存策略 Write Around 是什么？

Write Around 是一种缓存策略，它在写操作时绕过缓存，直接将数据写入后端存储（如数据库）。只有在读取数据时，才会将数据加载到缓存中。这种策略的主要目的是避免缓存污染，确保缓存中存储的是最常用的数据。

2. 缓存策略 Write Around 的应用场景

Write Around 适用于以下场景：

写密集型应用：当写操作远多于读操作时，使用 Write Around 可以避免缓存被频繁更新，减少缓存污染。
大数据量写入：当需要写入大量数据时，直接写入后端存储可以避免缓存空间不足的问题。
数据一致性要求不高：当对数据一致性要求不是特别高时，可以使用 Write Around 策略，因为写操作不会立即反映在缓存中。

3. 缓存策略 Write Around 的优缺点

优点：

避免缓存污染：写操作不更新缓存，避免了缓存中存储大量不常用的数据。
节省缓存空间：缓存中只存储最常用的数据，提高了缓存的利用率。
减少缓存更新开销：写操作不需要更新缓存，减少了缓存更新的开销。

缺点：

读性能下降：由于写操作不更新缓存，读操作时需要从后端存储中加载数据，增加了读取延迟。
数据一致性问题：写操作不更新缓存，可能导致缓存中的数据与后端存储中的数据不一致。
复杂性增加：需要额外的逻辑来处理读操作时的数据加载和缓存更新。

4. 用 Java 模拟使用 Write Around 策略

下面是一个简单的 Java 示例，模拟使用 Write Around 策略的缓存系统。

1. 创建缓存类

import java.util.HashMap;
import java.util.Map;

public class WriteAroundCache<K, V> {
    private final Map<K, V> cache;
    private final BackendStorage<K, V> backendStorage;

    public WriteAroundCache(BackendStorage<K, V> backendStorage) {
        this.cache = new HashMap<>();
        this.backendStorage = backendStorage;
    }

    public V get(K key) {
        V value = cache.get(key);
        if (value == null) {
            value = backendStorage.read(key);
            if (value != null) {
                cache.put(key, value); // 将数据加载到缓存中
            }
        }
        return value;
    }

    public void put(K key, V value) {
        backendStorage.write(key, value); // 直接写入后端存储
    }

    public void remove(K key) {
        cache.remove(key);
        backendStorage.delete(key);
    }
}

2. 创建后端存储类

public interface BackendStorage<K, V> {
    V read(K key);
    void write(K key, V value);
    void delete(K key);
}

public class InMemoryBackendStorage<K, V> implements BackendStorage<K, V> {
    private final Map<K, V> storage = new HashMap<>();

    @Override
    public V read(K key) {
        return storage.get(key);
    }

    @Override
    public void write(K key, V value) {
        storage.put(key, value);
    }

    @Override
    public void delete(K key) {
        storage.remove(key);
    }
}

3. 使用缓存

public class Main {
    public static void main(String[] args) {
        BackendStorage<String, String> backendStorage = new InMemoryBackendStorage<>();
        WriteAroundCache<String, String> cache = new WriteAroundCache<>(backendStorage);

        // 写操作
        cache.put("key1", "value1");
        cache.put("key2", "value2");

        // 读操作
        System.out.println("Read key1: " + cache.get("key1")); // 输出: Read key1: value1
        System.out.println("Read key2: " + cache.get("key2")); // 输出: Read key2: value2

        // 删除操作
        cache.remove("key1");
        System.out.println("Read key1 after delete: " + cache.get("key1")); // 输出: Read key1 after delete: null
    }
}