缓存与数据库数据一致性：旁路缓存、读写穿透和异步写入模式解析

已于 2025-04-24 16:33:21 修改
阅读量1.4k 收藏 31
点赞数 15
CC 4.0 BY-SA版权
文章标签： oracle 数据库 数据一致性 软件开发 架构设计 缓存
于 2025-04-24 16:21:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pinbodeshaonian/article/details/147481228

旁路缓存模式、读写穿透模式和异步缓存写入模式是三种常见的缓存使用模式，以下是对三种经典缓存使用模式在缓存与数据库数据一致性方面更全面的分析：

一、旁路缓存模式（Cache - Aside Pattern）

1.数据读取流程

  • 应用程序首先向缓存发送读取请求，检查所需数据是否在缓存中。
  • 如果缓存命中，直接从缓存中获取数据并返回给应用程序，这能极大提高读取速度，减少数据库的负载。
  • 若缓存未命中，应用程序接着向数据库发送读取请求，从数据库获取数据。获取到数据后，一方面将数据返回给应用程序，另一方面把数据写入缓存，同时可以设置缓存数据的过期时间，以便在数据更新后能及时从数据库重新获取最新数据。

2.数据写入流程

  • 当应用程序要更新数据时，首先更新数据库中的数据，确保数据库作为数据的可靠来源得到及时更新。
  • 在数据库更新成功后，立即删除缓存中对应的旧数据。这样做是为了让下次读取该数据时，能从数据库获取到最新数据并更新到缓存中，保证缓存数据的时效性。

3.一致性分析

  • 优点
    • 实现相对简单，在正常情况下能较好地保证数据一致性。以数据库为数据的权威来源，缓存主要用于加速读取，通过先更新数据库再删除缓存的操作顺序，多数情况下能确保缓存数据要么是最新的，要么不存在，等待下次读取时更新。
    • 读性能优化明显，缓存命中时能快速响应读取请求，减轻数据库压力，适用于读多写少的场景。
  • 缺点
    • 在高并发场景下可能出现数据不一致问题。例如，两个并发更新操作同时对同一数据进行修改，若操作 A 先更新数据库但在删除缓存前，操作 B 更新数据库并先于操作 A 删除缓存，接着操作 A 再删除缓存，此时缓存中无最新数据，读取请求可能获取到旧数据，直到下次缓存更新。
    • 缓存数据的过期时间设置较为关键，若设置过长，可能导致缓存数据长时间不一致；设置过短，则会增加数据库的读取压力。

4.代码实例

import redis.clients.jedis.Jedis;
import java.sql.*;

public class CacheAsidePattern {
    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final String DB_URL = "jdbc:mysql://localhost:3306/testdb";
    private static final String DB_USER = "root";
    private static final String DB_PASSWORD = "password";

    public static void main(String[] args) {
        try (Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
             Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD)) {

            // 创建表
            createTable(conn);
            // 插入示例数据
            insertSampleData(conn);

            // 测试读取
            String userName = getUser(jedis, conn, 1);
            System.out.println("用户姓名: " + userName);

            // 测试更新
            updateUser(jedis, conn, 1, "Bob");
            userName = getUser(jedis, conn, 1);
            System.out.println("更新后用户姓名: " + userName);

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private static void createTable(Connection conn) throws SQLException {
        String createTableSQL = "CREATE TABLE IF NOT EXISTS users (" +
                "id INT PRIMARY KEY, " +
                "name VARCHAR(255))";
        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate(createTableSQL);
        }
    }

    private static void insertSampleData(Connection conn) throws SQLException {
        String insertSQL = "INSERT IGNORE INTO users (id, name) VALUES (1, 'Alice')";
        try (PreparedStatement pstmt = conn.prepareStatement(insertSQL)) {
            pstmt.executeUpdate();
        }
    }

    private static String getUser(Jedis jedis, Connection conn, int userId) {
        String key = "user:" + userId;
        String user = jedis.get(key);
        if (user != null) {
            System.out.println("从缓存中获取数据");
            return user;
        } else {
            try (PreparedStatement pstmt = conn.prepareStatement("SELECT name FROM users WHERE id = ?")) {
                pstmt.setInt(1, userId);
                ResultSet rs = pstmt.executeQuery();
                if (rs.next()) {
                    user = rs.getString("name");
                    jedis.set(key, user);
                    System.out.println("从数据库中获取数据并写入缓存");
                    return user;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    private static void updateUser(Jedis jedis, Connection conn, int userId, String newName) {
        String key = "user:" + userId;
        try (PreparedStatement pstmt = conn.prepareStatement("UPDATE users SET name = ? WHERE id = ?")) {
            pstmt.setString(1, newName);
            pstmt.setInt(2, userId);
            pstmt.executeUpdate();
            jedis.del(key);
            System.out.println("数据库更新并删除缓存");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

二、读写穿透模式（Write - Through Pattern）

1.数据读取流程

  • 应用程序向缓存发送读取请求，尝试从缓存中获取数据。
  • 如果缓存命中，直接从缓存中返回数据给应用程序。
  • 若缓存未命中，应用程序从数据库读取数据，读取到数据后，将数据返回给应用程序，同时将数据写入缓存，且写入缓存操作是同步进行的，确保数据在缓存和数据库中同时更新。

2.数据写入流程

  • 当应用程序执行写操作时，会同时向缓存和数据库发送更新请求。先将数据写入缓存，然后由缓存负责将数据同步到数据库，通常通过缓存的写入操作触发对数据库的写入，保证缓存和数据库数据的实时同步。

3.一致性分析

  • 优点
    • 能严格保证数据一致性，每次读写操作都确保缓存和数据库的数据同步更新，两者就像一个整体，任何一方的更新立即反映到另一方，不存在数据延迟或不一致的情况。
    • 对于读写操作较为均衡的场景，该模式能较好地适应，不会出现因写操作频繁导致缓存与数据库数据不一致的问题。
  • 缺点
    • 由于缓存和数据库是不同存储系统，其写入性能和可靠性存在差异，可能出现缓存写入成功但数据库写入失败的情况，导致数据不一致。
    • 为保证一致性引入的补偿机制，如重试机制或事务机制，会增加系统复杂性和开发成本。同时，同步写入操作可能会降低写操作的性能，因为需要等待数据库写入完成才能返回结果。

4.代码实例

import redis.clients.jedis.Jedis;
import java.sql.*;

public class WriteThroughPattern {
    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final String DB_URL = "jdbc:mysql://localhost:3306/testdb";
    private static final String DB_USER = "root";
    private static final String DB_PASSWORD = "password";

    public static void main(String[] args) {
        try (Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
             Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD)) {

            // 创建表
            createTable(conn);
            // 插入示例数据
            insertSampleData(conn);

            // 测试读取
            String userName = getUser(jedis, conn, 1);
            System.out.println("用户姓名: " + userName);

            // 测试更新
            updateUser(jedis, conn, 1, "Bob");
            userName = getUser(jedis, conn, 1);
            System.out.println("更新后用户姓名: " + userName);

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private static void createTable(Connection conn) throws SQLException {
        String createTableSQL = "CREATE TABLE IF NOT EXISTS users (" +
                "id INT PRIMARY KEY, " +
                "name VARCHAR(255))";
        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate(createTableSQL);
        }
    }

    private static void insertSampleData(Connection conn) throws SQLException {
        String insertSQL = "INSERT IGNORE INTO users (id, name) VALUES (1, 'Alice')";
        try (PreparedStatement pstmt = conn.prepareStatement(insertSQL)) {
            pstmt.executeUpdate();
        }
    }

    private static String getUser(Jedis jedis, Connection conn, int userId) {
        String key = "user:" + userId;
        String user = jedis.get(key);
        if (user != null) {
            System.out.println("从缓存中获取数据");
            return user;
        } else {
            try (PreparedStatement pstmt = conn.prepareStatement("SELECT name FROM users WHERE id = ?")) {
                pstmt.setInt(1, userId);
                ResultSet rs = pstmt.executeQuery();
                if (rs.next()) {
                    user = rs.getString("name");
                    jedis.set(key, user);
                    System.out.println("从数据库中获取数据并写入缓存");
                    return user;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    private static void updateUser(Jedis jedis, Connection conn, int userId, String newName) {
        String key = "user:" + userId;
        try {
            conn.setAutoCommit(false);
            jedis.set(key, newName);
            try (PreparedStatement pstmt = conn.prepareStatement("UPDATE users SET name = ? WHERE id = ?")) {
                pstmt.setString(1, newName);
                pstmt.setInt(2, userId);
                pstmt.executeUpdate();
            }
            conn.commit();
            System.out.println("缓存和数据库同时更新");
        } catch (SQLException e) {
            try {
                conn.rollback();
            } catch (SQLException rollbackEx) {
                rollbackEx.printStackTrace();
            }
            System.out.println("更新失败: " + e.getMessage());
        }
    }
}

三、异步缓存写入模式（Write - Behind Caching Pattern）

1.数据读取流程

  • 与前两种模式类似，应用程序首先从缓存中读取数据。
  • 若缓存命中，直接返回数据。
  • 缓存未命中时，从数据库读取数据并返回给应用程序，同时将数据写入缓存。

2.数据写入流程

  • 写操作发生时，应用程序只将数据写入缓存，然后由缓存负责在后台异步地将数据批量写入数据库。可以根据一定的策略，如达到一定的写入次数或经过一定的时间间隔，将缓存中的数据批量刷写到数据库。

3.一致性分析

  • 优点
    • 写性能极高，应用程序无需等待数据库写入完成即可快速响应写请求，能显著提高系统吞吐量，适用于写操作频繁的场景，如日志记录、实时数据采集等。
    • 通过批量写入数据库，减少了数据库的写入次数，降低了数据库的 I/O 压力，有助于提高数据库的性能和稳定性。
  • 缺点
    • 数据一致性问题较为严重。由于数据是异步写入数据库的，在写入缓存后到写入数据库之前的时间段内，若发生系统故障、缓存数据丢失或缓存服务崩溃等情况，可能导致数据丢失，破坏数据一致性。
    • 为保证数据一致性采取的措施，如持久化缓存、合理设置缓存刷写策略、系统恢复时的数据恢复操作等，增加了系统的复杂性和运维成本。同时，还需考虑数据库写入的并发控制，避免数据冲突和不一致。

4.代码实例

import redis.clients.jedis.Jedis;
import java.sql.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class WriteBehindCachingPattern {
    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final String DB_URL = "jdbc:mysql://localhost:3306/testdb";
    private static final String DB_USER = "root";
    private static final String DB_PASSWORD = "password";
    private static final int FLUSH_INTERVAL = 5; // 每 5 秒刷写一次

    public static void main(String[] args) {
        try (Jedis jedis = new Jedis(REDIS_HOST, REDIS_PORT);
             Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD)) {

            // 创建表
            createTable(conn);
            // 插入示例数据
            insertSampleData(conn);

            // 启动异步刷写任务
            ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
            executor.scheduleAtFixedRate(() -> flushCacheToDB(jedis, conn), 0, FLUSH_INTERVAL, TimeUnit.SECONDS);

            // 测试读取
            String userName = getUser(jedis, conn, 1);
            System.out.println("用户姓名: " + userName);

            // 测试更新
            updateUser(jedis, conn, 1, "Bob");
            userName = getUser(jedis, conn, 1);
            System.out.println("更新后用户姓名: " + userName);

            // 关闭线程池
            executor.shutdown();

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private static void createTable(Connection conn) throws SQLException {
        String createTableSQL = "CREATE TABLE IF NOT EXISTS users (" +
                "id INT PRIMARY KEY, " +
                "name VARCHAR(255))";
        try (Statement stmt = conn.createStatement()) {
            stmt.executeUpdate(createTableSQL);
        }
    }

    private static void insertSampleData(Connection conn) throws SQLException {
        String insertSQL = "INSERT IGNORE INTO users (id, name) VALUES (1, 'Alice')";
        try (PreparedStatement pstmt = conn.prepareStatement(insertSQL)) {
            pstmt.executeUpdate();
        }
    }

    private static String getUser(Jedis jedis, Connection conn, int userId) {
        String key = "user:" + userId;
        String user = jedis.get(key);
        if (user != null) {
            System.out.println("从缓存中获取数据");
            return user;
        } else {
            try (PreparedStatement pstmt = conn.prepareStatement("SELECT name FROM users WHERE id = ?")) {
                pstmt.setInt(1, userId);
                ResultSet rs = pstmt.executeQuery();
                if (rs.next()) {
                    user = rs.getString("name");
                    jedis.set(key, user);
                    System.out.println("从数据库中获取数据并写入缓存");
                    return user;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    private static void updateUser(Jedis jedis, Connection conn, int userId, String newName) {
        String key = "user:" + userId;
        jedis.set(key, newName);
        System.out.println("数据写入缓存，等待异步刷写数据库");
    }

    private static void flushCacheToDB(Jedis jedis, Connection conn) {
        try {
            conn.setAutoCommit(false);
            // 模拟获取所有用户缓存数据
            // 实际应用中需要根据业务逻辑获取待刷写的数据
            String keyPattern = "user:*";
            for (String key : jedis.keys(keyPattern)) {
                int userId = Integer.parseInt(key.split(":")[1]);
                String userName = jedis.get(key);
                try (PreparedStatement pstmt = conn.prepareStatement("UPDATE users SET name = ? WHERE id = ?")) {
                    pstmt.setString(1, userName);
                    pstmt.setInt(2, userId);
                    pstmt.executeUpdate();
                }
            }
            conn.commit();
            System.out.println("缓存数据刷写到数据库");
        } catch (SQLException e) {
            try {
                conn.rollback();
            } catch (SQLException rollbackEx) {
                rollbackEx.printStackTrace();
            }
            System.out.println("刷写失败: " + e.getMessage());
        }
    }
}

三种经典缓存使用模式在缓存与数据库数据一致性方面各有优劣。在实际应用中，需要根据业务对数据一致性的严格程度、读写操作的频率和性能要求等因素，综合权衡选择合适的缓存模式，并通过相应的技术手段和策略来最大程度地保障数据一致性。

高并发下的分布式缓存 | Cache-Aside缓存模式
大厂小码农的博客
08-07 1822
在高并发的场景下，如果我们在更新数据时采用先使缓存失效，再更新数据库，如果某个时刻，同时有一个读请求和一个更新请求操作同一条数据，更新请求刚好让这条数据在缓存失效，然后读请求读取时缓存未命中（因为数据已被更新请求从缓存中删除），就会从数据库中获取旧数据并添加到缓存中。因此，代码需要实现重试机制。如果缓存中没有需要的数据，这叫做缓存未命中，这种情况下，应用程序需要从数据库中获取这个数据，从数据库中拿到数据后，应用程序还会将数据存入缓存，以便下次再需要这个数据时，可以直接从缓存里获取，而不需要再去查数据库。
【redis】缓存模式——穿透型缓存和旁路型缓存
wosixiaokeai的博客
07-03 511
定义：特点：适用场景： 穿透型缓存适用于读多写多的场景，数据一致性要求较高的应用。定义：特点：适用场景： 旁路型缓存适用于读多写少的场景，数据一致性要求不高的应用。在实际应用中，旁路型缓存常常结合同步写回和异步写回两种写回策略来平衡数据可靠性和性能。数据一致性：实现复杂度：适用场景：性能考虑：
.NET Core中的旁路缓存模式（Cache-Aside Pattern）
yan_yu_lv_ji的博客
01-24 373
通常情况下，我们需要专注于优化应用程序的性能。有很多方法可以做到这一点，其中一种方法是缓存一些数据。在这篇文章中，我将简要描述旁路缓存模式（）及其在 .NET Core中的简单实现。在这篇文章中，我描述了旁路缓存模式及其在 .NET Core中的主要实现。我还提出了增强设计，以少量的工作实现更优雅的解决方案。缓存快乐!🙂。
三种缓存模式
最新发布
weixin_44645022的博客
06-11 727
【代码】三种缓存模式。
缓存旁路模式
https://github.com/Wang-Jun-Chao
02-09 2521
【博文目录>>>】 缓存旁路模式 根据需要从数据存储区将数据加载到缓存中。这种模式可以提高性能，并有助于保持缓存中的数据与基础数据存储中的数据之间的一致性。 语境与问题 应用程序使用缓存优化对数据存储中保存的信息的重复访问。然而，期望缓存的数据始终与数据存储中的数据完全一致是不切实际的。应用程序应该实现一种策略，以帮助确保缓存中的数据尽可能地更新，但也可以检测和处理缓存中的数据...
【分布式技术】分布式缓存技术-旁路缓存模式(Cache Aside Pattern)
wendao76的专栏
11-13 2271
概述1. 读取操作（Read）2. 写入操作（Write）3. 一致性问题4. 解决方案适用于哪些场景？如何保证数据一致性？1. 延时双删策略具体是怎么工作的？写操作（更新或删除数据）读操作优点缺点实施注意事项2. 借助消息队列3. 读写穿透模式读写穿透模式具体是如何工作的？4. 异步回写模式（Write Behind Caching）Cache Aside Pattern（旁路缓存模式）是一种常见的缓存更新策略，其核心思想是将缓存的读取和更新操作与数据库的操作分开处理。
Redis 7.x 系列【37】旁路缓存模式
记录知识、锤炼自我
08-07 1852
缓存技术（Cache）通过将热点数据临时存储在查询速度更快的位置，从而提高了系统的响应速度和性能。‌ 计算机硬件、软件都大量使用了缓存技术，例如 CPU 中三级缓存，作为 CPU 与内存之间临时数据交换区， CPU 会将热点、相同的重复执行指令等数据放入到高速缓存中， CPU 直接从缓存中获取指令、数据，从而提高了整机的响应速度。
简历_基于 Cache Aside 模式解决数据库与缓存一致性问题。
buyaotutou的博客
01-18 975
缓存更新策略的最佳实践方案:1.低一致性需求:使用Redis自带的内存淘汰机制2.高一致性需求:主动更新，并以超时剔除作为兜底方案读操作:缓存命中则直接返回缓存未命中则查询数据库，并写入缓存，设定超时时间写操作:先写数据库，然后再删除缓存要确保数据库与缓存操作的原子性。
如何解决缓存（redis）和数据库（MySQL）数据不一致的问题？
jkzyx123的博客
09-08 1986
如何解决缓存（redis）和数据库（MySQL）数据不一致的问题？
缓存雪崩、击穿、穿透及解决方案_保证缓存和数据库一致性
liaoai的博客
11-22 1669
缓存雪崩、击穿、穿透及解决方案 保证缓存和数据库的一致性
数据库与缓存的一致性如何保证？
Chos1n__的博客
02-12 599
MySQL与Redis的数据一致性如何保证？一文学透
缓存常用的三种读写策略==》Cache Aside Pattern（旁路缓存模式）
xiyuanda的博客
03-08 4645
Cache Aside Pattern（旁路缓存模式） Cache Aside Pattern 中服务端需要同时维系 DB 和 cache，并且是以 DB 的结果为准。 下面我们来看一下这个策略模式下的缓存读写步骤。 写 ： 先更新 DB 然后直接删除 cache 。 简单画了一张图帮助大家理解写的步骤。 读 : 从 cache 中读取数据，读取到就直接返回 cache中读取不到的话，就从 DB 中读取数据返回 再把数据放到 cache 中。 .
旁路缓存模式（Cache-Aside Pattern）如何保证一致性的问题
AHAO的博客
12-14 2881
经典缓存模式：旁路缓存模式 (Cache-Aside Pattern)读缓存：接收用户读请求 --> 从缓存中查询数据 --> 命中缓存数据直接返回 --> 未命中则从数据库中查询数据。写缓存：接收用户写请求 --> 先写入数据库 --> 再写入缓存。读/写穿透模式 (Read/Write Through)将缓存操作(具体来说是数据读写操作)封装成一个缓存服务（Cache Provider），所有数据的读写操作都调用这个缓存服务。
Cache Aside Pattern（旁路缓存模式）在写数据的过程中，可以先删除 cache ，后更新 db 么？
qq_27037397的博客
09-07 418
不可以。以mysql 5.6为例，默认隔离级别为RR(可重复读)。线程1对数据进行更新，如果先删除缓存后更新DB，在两步中间若有线程2进行读数据操作，所读取的数据为更新前的数据，让后把此数据放入缓存。在此之后DB为新数据，缓存为旧数据，造成DB与缓存不一致
缓存背后的智慧：旁路、读写穿透和写回三种策略全面解析
沉梦听雨的博客
12-26 2510
问题：1、在写数据的过程中，可以先删除 cache，后更新 db 么？答：不可以，因为这样会导致数据库和缓存数据不一致的问题。举例：请求 1 先写数据 A，请求 2 随后读数据 A 的情况。db 的是新数据，cache 的是旧数据。2、在写数据的过程中，先更新 db，后删除 cache 就没有问题了吗？答：可能会有问题，但出现的概率非常小，因为【缓存】的写入速度比【数据库】的写入速度快很多。举例：请求 A 更新完数据库，但还未删除缓存，此时请求 B 命中了缓存并返回，就导致了数据不一致。
人人都要知道的，Redis缓存使用的三种模式
伍六七的博客
10-19 905
Cache Aside是一种常见的缓存模式，也是最简单的一种缓存模式。在Cache Aside模式中，应用程序首先从缓存中读取数据，如果缓存中不存在，则从数据库中读取数据，并将数据写入缓存中。在更新数据时，应用程序首先更新数据库中的数据，然后删除缓存中的数据。当下一次请求到来时，应用程序会从数据库中读取最新的数据，并将其写入缓存中。Cache Aside模式的优点是简单易用，缓存和数据库之间的数据一致性较好。
数仓DWS层之旁路缓存优化
JiaXingNashishua的博客
12-07 979
优化原因：旁路缓存模式是一种非常常见的按需分配缓存模式。所有请求优先访问缓存，若缓存命中，直接获得数据返回给请求者。如果未命中则查询数据库，获取结果后，将其返回并写入缓存以备后续请求使用。（1）旁路缓存策略应注意两点（2）缓存的选型一般两种：堆缓存或者独立缓存服务（memcache，redis）堆缓存，性能更好，效率更高，因为数据访问路径更短。但是难于管理，其它进程无法维护缓存中的数据。独立缓存服务（redis,memcache），会有创建连接、网络IO等消耗，较堆缓存略差，但性能尚可。独立缓存服务便于维护
oracle 旁路审计方案,Oracle数据库数据访问安全与审计方案
weixin_39571219的博客
04-03 283
Oracle数据库数据访问安全与审计方案，数据库系统是Oracle9.2.0.1，它的审计功能可实现该需求。这是一份真实的客户需求实现方案。客户要求监控到某些关键表在什么时间段、什么用户、什么应用程序以及访问哪些具体的记录。数据库系统是Oracle9.2.0.1，它的审计功能可实现该需求。基于审计对正常运行的应用的性能压力，需要设置特定时间段的数据访问审计。从审计日志中获得的监控详细信息，那些表被...
采用Cache Aside模式解决数据库与缓存的一致性问题 提出面试问题
04-03
<think>好的，我现在需要回答用户关于使用Cache Aside模式解决数据库与缓存一致性问题的请求，并且要提出相关的面试问题。首先，我需要回顾Cache Aside的基本概念和工作流程，确保自己对这一模式的理解正确。 Cache Aside模式，也叫旁路缓存策略，是处理数据库和缓存一致性的常用方法。它的核心思想是在读取数据时先查缓存，命中则返回，未命中则查数据库并更新缓存。写入数据时，先更新数据库，再使缓存失效。这样可以减少缓存与数据库不一致的情况。 接下来，我需要详细分解这个模式的各个步骤，确保用户能够清晰理解。比如，读流程和写流程的具体操作，以及为什么要这样设计。例如，在写操作中，为什么是先更新数据库再删除缓存，而不是更新缓存？这是因为在高并发场景下，如果先更新缓存，可能导致其他线程读取到旧数据，特别是在数据库更新失败的情况下，缓存中的新数据就会与数据库不一致。 然后，我需要考虑用户可能关心的异常情况，比如并发读写时的问题。例如，当两个线程同时更新同一个数据时，可能会出现缓存不一致的情况。这时候需要分析具体的时序，比如经典的“先写数据库再删除缓存”过程中，如果删除缓存失败，该怎么处理。可能需要引入重试机制或者消息队列来确保缓存最终被删除。 另外，用户可能想知道如何在实际项目中实现Cache Aside模式，是否需要配合其他机制，比如延迟双删或者设置缓存过期时间。这些细节都需要在回答中提及，以展示全面的理解。 接下来是面试问题的准备。我需要列举常见的面试问题，覆盖基本原理、异常处理、优缺点、与其他模式的对比等。例如，为什么选择先更新数据库再删除缓存？如何处理缓存删除失败的情况？Cache Aside和Read/Write Through模式有什么区别？这些问题能够帮助面试官评估候选人对缓存一致性问题的理解深度。 同时，还要考虑实际应用中的问题，比如在分布式系统中如何保证原子性操作，或者在高并发场景下如何优化性能。例如，使用异步队列来处理缓存删除失败的情况，或者使用分布式锁来避免并发写入导致的数据混乱。 最后，我需要验证自己的思路是否正确，是否有遗漏的关键点。例如，Cache Aside模式是否适用于所有场景？比如对于写多读少的场景，频繁删除缓存可能导致缓存命中率下降，这时候可能需要其他策略，如Write Behind等。这也是面试中可能被问到的问题，需要在回答中提及。 总结来说，我需要构建一个结构清晰、覆盖全面的回答，分步骤解释Cache Aside模式，并列举相关的面试问题，确保用户不仅理解基本概念，还能应对实际面试中的深入提问。</think>以下是关于Cache Aside模式的详细解析及常见面试问题： --- ### 一、Cache Aside模式核心原理 #### 1. 基本流程（两步操作） **读操作流程**： ```mermaid graph TD A[客户端请求数据] --> B{缓存是否存在?} B -- 存在 --> C[直接返回缓存数据] B -- 不存在 --> D[查询数据库] D --> E[将数据写入缓存] E --> F[返回数据] ``` **写操作流程**： ```mermaid graph TD A[更新数据库] --> B[删除缓存] B --> C{是否需要重试?} C -- 删除失败 --> D[异步队列重试删除] C -- 成功 --> E[结束] ``` #### 2. 关键设计原则 - **写策略**：先更新数据库，再删除缓存（*非更新缓存*） $$操作序列 = Write\ DB \rightarrow Delete\ Cache$$ - **读策略**：缓存未命中时，从数据库加载后回填缓存 $$操作序列 = Read\ Cache \xrightarrow{Miss} Read\ DB \rightarrow Set\ Cache$$ --- ### 二、解决一致性问题的核心机制 #### 1. 应对并发写入问题 - **场景**：两个并发写操作可能导致缓存与数据库不一致 **解决**：通过时序控制确保最终一致性 ```text 时序示例： 1. 线程A更新数据库为X=1 2. 线程B更新数据库为X=2 3. 线程B删除缓存 4. 线程A删除缓存（覆盖了B的删除） → 最终缓存会被后续读请求正确回填 ``` #### 2. 缓存删除失败处理 - **重试机制**：通过消息队列（如Kafka）异步重试删除 ```java // 伪代码示例 try { cache.delete(key); } catch (Exception e) { mq.send(new DeleteCacheMessage(key)); // 发送到重试队列 } ``` - **过期时间兜底**：设置缓存过期时间（如30分钟），防止长期不一致 --- ### 三、典型面试问题及参考答案 #### 1. 为什么选择先更新数据库再删除缓存？ - **参考答案**： 1. 若先删除缓存，在数据库更新完成前可能有请求穿透到数据库，导致旧数据回填缓存 2. 先更新数据库能保证最终一致性，即使删除缓存失败，后续读请求也会回填正确数据 #### 2. 如何处理高并发下的“先删缓存再更新数据库”问题？ - **参考答案**： 可能产生脏读（其他线程在数据库更新前读取旧值回填缓存） **解决方案**： 1. 使用“延迟双删”（更新数据库后延时二次删除缓存） 2. 通过数据库binlog监听（如Canal）异步更新缓存 #### 3. Cache Aside与Read/Write Through模式的区别？ - **参考答案**： - **Cache Aside**：应用层直接管理缓存和数据库 - **Read/Write Through**：缓存作为数据库代理，应用只与缓存交互 - **Write Behind**：异步批量更新数据库，风险是可能丢失数据 #### 4. 如何避免缓存击穿导致数据库压力？ - **参考答案**： 1. 使用互斥锁（如Redis SETNX）控制单线程回填缓存 2. 布隆过滤器拦截无效Key 3. 缓存空值（如`SET key null EX 60`） #### 5. 什么场景下Cache Aside不适用？ - **参考答案**： 1. 写多读少场景：频繁删除缓存降低命中率 2. 强一致性需求：需结合分布式锁或2PC协议 3. 多级缓存架构：需额外协调各级缓存 --- ### 四、优化实践方案 #### 1. 最终一致性增强 ```java // 使用数据库事务日志监听（如MySQL Binlog + Canal） canalClient.subscribe(binlogEvent -> { if (event.isUpdate()) { redis.delete(event.getKey()); // 异步删除缓存 } }); ``` #### 2. 热点数据预加载 ```text 监控系统识别热点Key → 提前加载到缓存 → 设置永不过期+版本号控制 ``` #### 3. 降级策略 - **缓存不可用**：直接访问数据库，记录日志告警 - **数据库压力过大**：限流熔断（如Sentinel） --- ### 五、常见陷阱 1. **双写不一致** - **错误**：并行更新数据库和缓存 - **正确**：严格遵循“先DB后缓存删除” 2. **缓存雪崩** - **错误**：大量缓存同时过期 - **正确**：随机化过期时间（如基础300秒±60秒随机） 3. **脑裂问题** - **场景**：主从同步延迟期间读取到旧数据 - **解决**：写后主库读、缓存设置版本号 --- 该方案在电商秒杀系统中得到验证，需结合监控（如缓存命中率、DB QPS）动态调整策略。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

编程在手天下我有

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值