MySQL · 源码阅读· MySQL 如何响应 KILL

MySQL 如何响应 kill

我们使用 MySQL 时经常会遇到需要中止一条查询的时候, 本文讨论 kill 命令的效果及其实现。

三种不同的 kill 命令

从 MySQL 官网上我们可以看到 kill 命令格式如下:

  1. KILL [CONNECTION | QUERY] processlist_id

首先说明要做 kill, 然后指定 kill 的级别:

  • CONNECTION, kill 之后 processlist_id 对应的查询中止, 对应的连接退出, 如果没有查询, 那么连接直接退出
  • QUERY, kill 之后 processlist_id 对应的查询中止, 连接保持

下面我们针对这两种情况进行一些简单的测试, 看看实际效果.

kill query

我们先制造一个简单的可以 kill 的情况, 为了避免需要太多数据, 我们选择制造一个被锁住的情况, 然后 kill 被锁住的连接. 首先连接数据库, 使用当前连接 (之后称为 C1) 创建一张简单的表:

  1.  -- IN C1
  2.  CREATE TABLE `t1` (
  3.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  4.   `k` int(10) unsigned NOT NULL DEFAULT '0',
  5.   `c` char(120) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '',
  6.   `pad` char(60) COLLATE utf8mb4_general_ci NOT NULL DEFAULT '',
  7.   PRIMARY KEY (`id`),
  8.   KEY `k_1` (`k`)
  9. ) ENGINE=InnoDB;

随意写入一些数据. 然后我们执行

  1. -- IN C1
  2. lock tables t1 write;

此时再创建一个新的连接 (之后称为 C2), 执行

  1. -- IN C2
  2. SELECT COUNT(*) FROM t1;

此时会观测到:

  1. +----------+-----------------+-----------+--------+---------+-------+---------------------------------+-------------------------+
  2. | Id       | User            | Host      | db     | Command | Time  | State                           | Info                    |
  3. +----------+-----------------+-----------+--------+---------+-------+---------------------------------+-------------------------+
  4. | 123      | AAA             | localhost | XXX    | Query   |     0 | starting                        | show processlist        |
  5. | 124      | AAA             | localhost | XXX    | Query   |     2 | Waiting for table metadata lock | select count(*) from t1 |
  6. +----------+-----------------+-----------+--------+---------+-------+---------------------------------+-------------------------+

执行 kill

  1. -- IN C1
  2. KILL QUERY 124;

此时 C2 会显示 Query execution was interrupted, 同时 C2 的连接仍然存在可以继续执行查询.

kill connection

类似上面的操作, 只不过把 kill 操作变为

  1. -- IN C1
  2. KILL CONNECTION 124;

或

  1. -- IN C1
  2. KILL 124;

此时 C2 报错为 Lost connection to MySQL server during query, 124 连接也一同消失了.

Ctrl+C

Ctrl+C 在我们做测试时经常发生, 我们使用 MySQL 客户端以可交互的方式连接 MySQL, 之后我们发出一条 SQL , 但发现一些问题, 希望停下当前的查询, 重新执行. 此时因为之前在执行查询的 session 已经被占用了, 因此 MySQL 客户端会新建立一个临时的 connection, 将 kill query 的命令发送给 MySQL 服务, 之后再回收掉临时的 connection. 这条命令在 MySQL 服务端看起来和 kill query 看起来是一样的.

两种不同的 kill 响应

kill 标记

当执行 kill 命令时, 会根据命令中指定的 process id, 查找对应的连接结构体, 并设置 kill 标记, 查询执行过程中, 会在各种位置检测 THD 上的 kill 标记, 如果发现 kill 标记被设置, 那么中止执行, 并做清理退出. 省略了很多检查部分的代码, 主要的 kill 路径代码如下:

  1. static uint kill_one_thread(THD *thd, my_thread_id id, bool only_kill_query) {
  2.   THD *tmp = NULL;
  3.   uint error = ER_NO_SUCH_THREAD;
  4.   Find_thd_with_id find_thd_with_id(id);
  6.   // ...
  7.   tmp = Global_THD_manager::get_instance()->find_thd(&find_thd_with_id);
  8.   // ...
  9.   tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
  10.   // ...
  11. }
  13. void THD::awake(THD::killed_state state_to_set) {
  14.   // ...
  15.   if (this->m_server_idle && state_to_set == KILL_QUERY) { /* nothing */
  16.   } else {
  17.     killed = state_to_set;
  18.   }
  19.   // ...
  20. }

执行过程中响应

  • 在 SELECT 查询过程中, 每读取一行就会检查一次

    1. int TableScanIterator::Read() {
    2.   int tmp;
    3.   while ((tmp = table()->file->ha_rnd_next(m_record))) {
    4.       /*
    5.       ha_rnd_next can return RECORD_DELETED for MyISAM when one thread is
    6.       reading and another deleting without locks.
    7.       */
    8.       if (tmp == HA_ERR_RECORD_DELETED && !thd()->killed) continue;
    9.       return HandleError(tmp);
    10.   }
    11.   if (m_examined_rows != nullptr) {
    12.       ++*m_examined_rows;
    13.   }
    14.   return 0;
    15. }
    17. int IndexRangeScanIterator::Read() {
    18.   int tmp;
    19.   while ((tmp = m_quick->get_next())) {
    20.       if (thd()->killed || (tmp != HA_ERR_RECORD_DELETED)) {
    21.       return HandleError(tmp);
    22.       }
    23.   }
    25.   if (m_examined_rows != nullptr) {
    26.       ++*m_examined_rows;
    27.   }
    28.   return 0;
    29. }

  • 在进行表复制操作的 ALTER TABLE 命令进行时, 每读取源表的一些行, 就会进行检查, 如果发现被 kill, 那么会停止复制并删除创建的临时表

    1. static int copy_data_between_tables(/* 很多参数 ... */) {
    2.   // ...
    3.   to->file->extra(HA_EXTRA_BEGIN_ALTER_COPY);
    5.   while (!(error = info->Read())) {
    6.     if (thd->killed) {
    7.       thd->send_kill_message();
    8.       error = 1;
    9.       break;
    10.     }
    11.     // ... copy data
    12.   }
    13.   // ... clean up

  • 在 UPDATE 和 DELETE 操作中, 在读取数据或者进行任何更新删除时都会检查, 如果开启了事务, 那么事务会在 kill 之后回滚

    1. void delete_from_single_table(THD *) {
    2.   // ...
    3.   while (!(error = info->Read()) && !thd->killed) {
    4.     DBUG_ASSERT(!thd->is_error());
    5.     thd->inc_examined_row_count(1);
    6.     // ...
    7.   }
    8.   // ...
    9. }
    11. void update_single_table(THD *) {
    12.   // ...
    13.   while (!(error = info->Read()) && !thd->killed) {
    14.     DBUG_ASSERT(!thd->is_error());
    15.     thd->inc_examined_row_count(1);
    16.     // ...
    17.   }
    18.   // ...
    19. }

  • kill GET_LOCK 命令会使其返回 NULL

  • 对于已经加锁的线程, 响应 kill 之后会释放已经得到的锁, 数据库中有相当多的锁, 这部分其实是一个很可能遇到的情况, MySQL 有专门的处理机制, 在下面单独讨论实现

等待中响应

如果查询此时等待在某个 condition_variable 上, 那么短时间内可能很难唤醒, 如果出现了死锁的情况, 那么就更不可能唤醒了, 因此, kill 实现了针对等待的特殊响应, 其主要思路是

  • 在某个查询进入等待状态之前, 在 THD 上记录下当前查询等待的 condition_variable 对象及其对应的 mutex

    1.   void enter_cond(mysql_cond_t *cond, mysql_mutex_t *mutex,
    2.                   const PSI_stage_info *stage, PSI_stage_info *old_stage,
    3.                   const char *src_function, const char *src_file,
    4.                   int src_line) {
    5.   DBUG_ENTER("THD::enter_cond");
    6.   mysql_mutex_assert_owner(mutex);
    7.   current_mutex = mutex;
    8.   current_cond = cond;
    9.   enter_stage(stage, old_stage, src_function, src_file, src_line);
    10.   DBUG_VOID_RETURN;
    11. }

  • 在等待的条件上增加对 thd->killed 状态的判断, 即检测到 killed 时退出等待

    1. longlong Item_func_sleep::val_int() {
    2.   THD *thd = current_thd;
    3.   Interruptible_wait timed_cond(thd);
    4.   mysql_cond_t cond;
    5.   // ...
    6.   timeout = args[0]->val_real();
    7.   mysql_cond_init(key_item_func_sleep_cond, &cond);
    8.   mysql_mutex_lock(&LOCK_item_func_sleep);
    10.   thd->ENTER_COND(&cond, &LOCK_item_func_sleep, &stage_user_sleep, NULL);
    12.   error = 0;
    13.   thd_wait_begin(thd, THD_WAIT_SLEEP);
    14.   while (!thd->killed) {
    15.       error = timed_cond.wait(&cond, &LOCK_item_func_sleep);
    16.       if (is_timeout(error)) break;
    17.       error = 0;
    18.   }
    19.   thd_wait_end(thd);
    20.   mysql_mutex_unlock(&LOCK_item_func_sleep);
    21.   thd->EXIT_COND(NULL);
    23.   mysql_cond_destroy(&cond);
    25.   return (error == 0);  // Return 1 killed
    26. }

  • kill 发生时, 使用 THD 记录的 condition_variable 进行 pthread_cond_signal, 唤醒等待者, 等待者醒来会检测 kill 标记, 发现已被 kill 从而快速退出, 这段代码也位于 THD::awake 中.

    1. void THD::awake(THD::killed_state state_to_set) {
    2.   // ...
    3.   /* Broadcast a condition to kick the target if it is waiting on it. */
    4.   if (is_killable) {
    5.       mysql_mutex_lock(&LOCK_current_cond);
    6.       if (current_cond.load() && current_mutex.load()) {
    7.       DBUG_EXECUTE_IF("before_dump_thread_acquires_current_mutex", {
    8.           const char act[] =
    9.               "now signal dump_thread_signal wait_for go_dump_thread";
    10.           DBUG_ASSERT(!debug_sync_set_action(current_thd, STRING_WITH_LEN(act)));
    11.       };);
    12.       mysql_mutex_lock(current_mutex);
    13.       mysql_cond_broadcast(current_cond);
    14.       mysql_mutex_unlock(current_mutex);
    15.       }
    16.       mysql_mutex_unlock(&LOCK_current_cond);
    17.   }
    18.   DBUG_VOID_RETURN;
    19. }

为什么有时候无法 kill

有时候 kill 命令发出了, show processlist 可以看到 session 状态已经变为 Killed 状态了, 但是查询仍在执行, 这多数情况是由于这个 session 的查询未运行到检查点, 没有发现自己已经被 kill 了, 这个查询可能在引擎层内部执行比较复杂的工作, 也可能在读写临时表进行繁重的 IO. 此时一般只能继续等待程序运行到检查点, 发现 kill 状态后, 就会退出了.