MySQL的Query Cache在MySQL 8.0被移除的原因，以及如何利用Redis或Memcached作为替代方案进行外部缓存？ - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

MySQL 8.0 移除 Query Cache：原因与替代方案

各位朋友，大家好。今天我们来聊聊一个在MySQL发展史上比较重要的变化：Query Cache的移除，以及如何利用外部缓存系统，比如Redis或Memcached，来替代Query Cache的功能。

Query Cache 的前世今生

在MySQL 5.x 和早期 8.0 版本中，Query Cache 扮演着重要的角色。它的核心思想是，将SELECT语句的查询结果缓存起来，当收到完全相同的查询请求时，直接从缓存中返回结果，而无需再次执行SQL语句。这在某些场景下，可以显著提高查询性能，尤其是在读多写少的环境中。

Query Cache 的工作流程大致如下：

客户端发送一条 SELECT 语句到 MySQL 服务器。
服务器首先检查 Query Cache 中是否已经存在该查询的结果。检查的标准是查询语句的文本（包括空格、大小写等）是否完全一致。
如果找到匹配的缓存结果，服务器直接将缓存的结果返回给客户端，跳过SQL解析、优化和执行等步骤。
如果没有找到匹配的缓存结果，服务器按照正常的流程执行SQL语句，并将结果返回给客户端。
同时，服务器会将查询语句和结果存储到 Query Cache 中，以便后续使用。

我们可以通过一些参数来配置 Query Cache，例如：

query_cache_type: 控制 Query Cache 的开启和关闭。取值可以是 OFF、ON 或 DEMAND。
query_cache_size: 设置 Query Cache 的大小，单位是字节。
query_cache_limit: 设置单个查询结果可以缓存的最大大小，单位是字节。
query_cache_min_res_unit: 设置 Query Cache 分配内存的最小单元大小，单位是字节。

示例：查看 Query Cache 配置

SHOW VARIABLES LIKE 'query_cache%';

查询结果可能如下：

Variable_name	Value
query_cache_limit	1048576
query_cache_min_res_unit	4096
query_cache_size	16777216
query_cache_type	ON
query_cache_wlock_invalidate	OFF

Query Cache 的弊端：为何被移除？

虽然 Query Cache 在理论上很美好，但在实际应用中却存在一些难以克服的问题，最终导致它在 MySQL 8.0 中被彻底移除。

高并发场景下的锁竞争： Query Cache 是一个全局共享的资源，当多个线程同时访问 Query Cache 时，需要进行锁竞争。在高并发场景下，锁竞争会非常激烈，导致性能下降。即使是读取操作，也需要获取锁来保证数据的一致性。
缓存失效问题： 只要表中的数据发生任何变化（包括插入、更新、删除等操作），所有依赖该表的 Query Cache 都需要失效。这个过程会消耗大量的 CPU 资源，并且可能会导致短时间的性能抖动。
内存碎片： Query Cache 使用的是动态内存分配，长时间运行后容易产生内存碎片，降低缓存的利用率。
查询语句的严格匹配： Query Cache 要求查询语句必须完全一致才能命中缓存，包括空格、大小写等。这导致 Query Cache 的命中率往往不高，即使查询语句的逻辑相同，但由于细微的差异，也无法命中缓存。
维护成本高： Query Cache 的内部实现比较复杂，维护成本较高。随着 MySQL 的不断发展，Query Cache 逐渐成为一个负担，阻碍了 MySQL 性能的进一步提升。

总的来说，Query Cache 在高并发、频繁更新的场景下，非但不能提高性能，反而会成为瓶颈。因此，MySQL 团队最终决定在 8.0 版本中移除 Query Cache。

Redis/Memcached：外部缓存的替代方案

Query Cache 被移除后，我们需要寻找其他的缓存方案来提高查询性能。一个常见的选择是使用外部缓存系统，比如 Redis 或 Memcached。

Redis 和 Memcached 的区别：

特性	Redis	Memcached
数据结构	支持多种数据结构，如字符串、哈希表、列表、集合、有序集合等。	只支持简单的键值对存储。
持久化	支持 RDB 和 AOF 两种持久化方式，可以将数据保存到磁盘上。	不支持持久化，数据存储在内存中，重启后数据会丢失。
分布式	原生支持集群模式，可以实现数据的自动分片和负载均衡。	需要借助第三方客户端来实现分布式，如 Twemproxy。
内存管理	提供多种内存淘汰策略，如 LRU、LFU、随机淘汰等。	默认使用 LRU 算法进行内存淘汰。
使用场景	适合存储复杂的数据结构，需要持久化和分布式支持的场景，如会话管理、排行榜、消息队列等。	适合存储简单的键值对数据，对性能要求高，但不需要持久化的场景，如缓存页面、缓存数据等。
性能	通常情况下，Memcached 的性能略高于 Redis，但 Redis 的功能更强大。	通常情况下，Memcached 的性能略高于 Redis，但 Redis 的功能更强大。

选择哪种缓存系统取决于具体的应用场景。 如果需要存储复杂的数据结构，或者需要持久化和分布式支持，Redis 是一个更好的选择。如果只需要存储简单的键值对数据，并且对性能要求很高，Memcached 也是一个不错的选择。

使用 Redis/Memcached 作为外部缓存

使用 Redis 或 Memcached 作为 MySQL 的外部缓存，通常需要在应用程序的代码中进行修改。大致的流程如下：

查询数据时，首先尝试从缓存中获取数据。
如果缓存中存在数据，则直接返回缓存的数据。
如果缓存中不存在数据，则执行 SQL 查询，并将查询结果存储到缓存中，然后再返回数据。
当数据库中的数据发生变化时，需要及时更新或删除缓存中的数据，以保证数据的一致性。

下面我们分别以 PHP 和 Python 为例，演示如何使用 Redis 和 Memcached 作为 MySQL 的外部缓存。

PHP 示例 (使用 Redis):

<?php

// Redis 连接信息
$redis_host = '127.0.0.1';
$redis_port = 6379;
$redis_db = 0;

// MySQL 连接信息
$mysql_host = '127.0.0.1';
$mysql_user = 'root';
$mysql_password = 'password';
$mysql_database = 'test';

// 连接 Redis
$redis = new Redis();
$redis->connect($redis_host, $redis_port);
$redis->select($redis_db);

// 连接 MySQL
$mysqli = new mysqli($mysql_host, $mysql_user, $mysql_password, $mysql_database);
if ($mysqli->connect_error) {
    die('Connect Error (' . $mysqli->connect_errno . ') '
            . $mysqli->connect_error);
}

// 定义一个函数，用于从缓存或数据库中获取数据
function get_data($sql) {
    global $redis, $mysqli;

    // 将 SQL 语句作为缓存的 key
    $cache_key = md5($sql);

    // 尝试从 Redis 中获取数据
    $data = $redis->get($cache_key);

    if ($data) {
        // 如果缓存中存在数据，则直接返回
        echo "从 Redis 缓存中获取数据n";
        return json_decode($data, true);
    } else {
        // 如果缓存中不存在数据，则执行 SQL 查询
        echo "从 MySQL 数据库中获取数据n";
        $result = $mysqli->query($sql);

        if ($result) {
            $data = [];
            while ($row = $result->fetch_assoc()) {
                $data[] = $row;
            }

            // 将查询结果存储到 Redis 中，设置过期时间为 60 秒
            $redis->setex($cache_key, 60, json_encode($data));

            // 释放结果集
            $result->free();

            return $data;
        } else {
            return false;
        }
    }
}

// 示例：查询用户表中的所有数据
$sql = "SELECT * FROM users";
$users = get_data($sql);

if ($users) {
    print_r($users);
} else {
    echo "查询失败n";
}

// 关闭连接
$mysqli->close();
$redis->close();

?>

PHP 示例 (使用 Memcached):

<?php

// Memcached 连接信息
$memcached_host = '127.0.0.1';
$memcached_port = 11211;

// MySQL 连接信息
$mysql_host = '127.0.0.1';
$mysql_user = 'root';
$mysql_password = 'password';
$mysql_database = 'test';

// 连接 Memcached
$memcached = new Memcached();
$memcached->addServer($memcached_host, $memcached_port);

// 连接 MySQL
$mysqli = new mysqli($mysql_host, $mysql_user, $mysql_password, $mysql_database);
if ($mysqli->connect_error) {
    die('Connect Error (' . $mysqli->connect_errno . ') '
            . $mysqli->connect_error);
}

// 定义一个函数，用于从缓存或数据库中获取数据
function get_data($sql) {
    global $memcached, $mysqli;

    // 将 SQL 语句作为缓存的 key
    $cache_key = md5($sql);

    // 尝试从 Memcached 中获取数据
    $data = $memcached->get($cache_key);

    if ($data) {
        // 如果缓存中存在数据，则直接返回
        echo "从 Memcached 缓存中获取数据n";
        return $data;
    } else {
        // 如果缓存中不存在数据，则执行 SQL 查询
        echo "从 MySQL 数据库中获取数据n";
        $result = $mysqli->query($sql);

        if ($result) {
            $data = [];
            while ($row = $result->fetch_assoc()) {
                $data[] = $row;
            }

            // 将查询结果存储到 Memcached 中，设置过期时间为 60 秒
            $memcached->set($cache_key, $data, 60);

            // 释放结果集
            $result->free();

            return $data;
        } else {
            return false;
        }
    }
}

// 示例：查询用户表中的所有数据
$sql = "SELECT * FROM users";
$users = get_data($sql);

if ($users) {
    print_r($users);
} else {
    echo "查询失败n";
}

// 关闭连接
$mysqli->close();
$memcached->quit();

?>

Python 示例 (使用 Redis):

import redis
import pymysql
import hashlib
import json

# Redis 连接信息
redis_host = '127.0.0.1'
redis_port = 6379
redis_db = 0

# MySQL 连接信息
mysql_host = '127.0.0.1'
mysql_user = 'root'
mysql_password = 'password'
mysql_database = 'test'

# 连接 Redis
redis_client = redis.Redis(host=redis_host, port=redis_port, db=redis_db)

# 连接 MySQL
mysql_connection = pymysql.connect(host=mysql_host, user=mysql_user, password=mysql_password, database=mysql_database)
mysql_cursor = mysql_connection.cursor()

# 定义一个函数，用于从缓存或数据库中获取数据
def get_data(sql):
    global redis_client, mysql_cursor, mysql_connection

    # 将 SQL 语句作为缓存的 key
    cache_key = hashlib.md5(sql.encode('utf-8')).hexdigest()

    # 尝试从 Redis 中获取数据
    data = redis_client.get(cache_key)

    if data:
        # 如果缓存中存在数据，则直接返回
        print("从 Redis 缓存中获取数据")
        return json.loads(data.decode('utf-8'))
    else:
        # 如果缓存中不存在数据，则执行 SQL 查询
        print("从 MySQL 数据库中获取数据")
        mysql_cursor.execute(sql)
        result = mysql_cursor.fetchall()

        data = []
        for row in result:
            data.append(dict(zip([column[0] for column in mysql_cursor.description], row)))

        # 将查询结果存储到 Redis 中，设置过期时间为 60 秒
        redis_client.setex(cache_key, 60, json.dumps(data))

        return data

# 示例：查询用户表中的所有数据
sql = "SELECT * FROM users"
users = get_data(sql)

if users:
    print(users)
else:
    print("查询失败")

# 关闭连接
mysql_cursor.close()
mysql_connection.close()

Python 示例 (使用 Memcached):

import memcache
import pymysql
import hashlib
import json

# Memcached 连接信息
memcached_host = '127.0.0.1'
memcached_port = 11211

# MySQL 连接信息
mysql_host = '127.0.0.1'
mysql_user = 'root'
mysql_password = 'password'
mysql_database = 'test'

# 连接 Memcached
memcached_client = memcache.Client([f'{memcached_host}:{memcached_port}'])

# 连接 MySQL
mysql_connection = pymysql.connect(host=mysql_host, user=mysql_user, password=mysql_password, database=mysql_database)
mysql_cursor = mysql_connection.cursor()

# 定义一个函数，用于从缓存或数据库中获取数据
def get_data(sql):
    global memcached_client, mysql_cursor, mysql_connection

    # 将 SQL 语句作为缓存的 key
    cache_key = hashlib.md5(sql.encode('utf-8')).hexdigest()

    # 尝试从 Memcached 中获取数据
    data = memcached_client.get(cache_key)

    if data:
        # 如果缓存中存在数据，则直接返回
        print("从 Memcached 缓存中获取数据")
        return data
    else:
        # 如果缓存中不存在数据，则执行 SQL 查询
        print("从 MySQL 数据库中获取数据")
        mysql_cursor.execute(sql)
        result = mysql_cursor.fetchall()

        data = []
        for row in result:
            data.append(dict(zip([column[0] for column in mysql_cursor.description], row)))

        # 将查询结果存储到 Memcached 中，设置过期时间为 60 秒
        memcached_client.set(cache_key, data, time=60)

        return data

# 示例：查询用户表中的所有数据
sql = "SELECT * FROM users"
users = get_data(sql)

if users:
    print(users)
else:
    print("查询失败")

# 关闭连接
mysql_cursor.close()
mysql_connection.close()

在以上示例中，我们使用了 SQL 语句的 MD5 值作为缓存的 key，并将查询结果以 JSON 格式存储到 Redis 或 Memcached 中。同时设置了缓存的过期时间为 60 秒。

需要注意的是，缓存的 key 的设计非常重要。 一个好的 key 应该能够唯一标识一个查询，并且应该尽可能短，以减少内存的占用。

数据一致性问题：

使用外部缓存时，需要特别注意数据一致性问题。当数据库中的数据发生变化时，需要及时更新或删除缓存中的数据，以避免出现脏数据。常见的解决方案包括：

Cache-Aside (旁路缓存): 应用程序负责维护缓存，当数据发生变化时，先更新数据库，然后删除缓存。下次查询时，如果缓存未命中，则从数据库中读取数据，并更新缓存。
Read-Through/Write-Through: 缓存系统负责维护缓存，应用程序只需要与缓存系统交互。当读取数据时，缓存系统会自动从数据库中读取数据，并更新缓存。当写入数据时，缓存系统会自动更新数据库和缓存。
Write-Behind (异步写回): 当写入数据时，先更新缓存，然后异步地将数据写入数据库。这种方式可以提高写入性能，但可能会导致数据丢失。

选择哪种数据一致性解决方案取决于具体的应用场景和对数据一致性的要求。

结论

MySQL 8.0 移除 Query Cache 是一个正确的选择，因为它在高并发、频繁更新的场景下反而会降低性能。使用外部缓存系统，比如 Redis 或 Memcached，可以更好地提高查询性能，并解决 Query Cache 存在的问题。在使用外部缓存时，需要注意缓存 key 的设计、数据一致性问题，以及缓存的过期时间等。

希望今天的讲解对大家有所帮助。

缓存方案的选取

选择合适的缓存策略，需要综合考虑数据更新频率、查询模式和性能需求，并非所有查询都适合缓存。

代码之外的考虑

缓存的管理和监控同样重要，合理的监控可以帮助我们及时发现和解决缓存相关的问题。