// 为了防止出现死锁，当前会话执行STOP命令之前不能存在表锁
case SQLCOM_SLAVE_STOP: {
  if (thd->locked_tables_mode || thd->in_active_multi_stmt_transaction() ||
      thd->global_read_lock.is_acquired()) {
    my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
    goto error;
  }  res = stop_slave_cmd(thd);
  break;
}

  // 先获取备份锁（lock instance for backup）
  MDL_lock_guard backup_sentry{thd};
  /* During provisioning we stop slave after acquiring backup lock. */
  if (!Clone_handler::is_provisioning() &&
      (!thd->lex->slave_thd_opt || (thd->lex->slave_thd_opt & SLAVE_SQL))) {
    if (backup_sentry.lock(MDL_key::BACKUP_LOCK, MDL_INTENTION_EXCLUSIVE)) {
      my_error(ER_RPL_CANT_STOP_SLAVE_WHILE_LOCKED_BACKUP, MYF(0));
      channel_map.unlock();
      return true;
    }
  }

// 如果没有指定channel name，则停止所有运行中的channel
  if (!lex->mi.for_channel)
    res = stop_slave(thd);
  else {
    // 否则获取并停止指定的channel
    mi = channel_map.get_mi(lex->mi.channel);
......
 // 对指定的channel执行STOP操作
    if (mi)
      res = stop_slave(thd, mi, true /*net report */, true /*for_one_channel*/,
                       &push_temp_table_warning);
    else if (strcmp(channel_map.get_default_channel(), lex->mi.channel))
      my_error(ER_SLAVE_CHANNEL_DOES_NOT_EXIST, MYF(0), lex->mi.channel);
  }

  channel_map.unlock();

  // 如果不是多源复制则停止默认channel
  if (channel_map.get_num_instances() == 1) {
    mi = channel_map.get_default_channel_mi();

    assert(!strcmp(mi->get_channel(), channel_map.get_default_channel()));

    error = stop_slave(thd, mi, true, false /*for_one_channel*/,
                       &push_temp_table_warning);
  } else {
    // 如果为多源复制则循环停止所有的channel
    for (mi_map::iterator it = channel_map.begin(); it != channel_map.end();
         it++) {
      mi = it->second;

      if (Master_info::is_configured(mi)) {
        if (stop_slave(thd, mi, true, false /*for_one_channel*/,
                       &push_temp_table_warning)) {
          LogErr(ERROR_LEVEL, ER_RPL_SLAVE_CANT_STOP_SLAVE_FOR_CHANNEL,
                 mi->get_channel());
          error = 1;
        }
      }
    }

  /*
    因为需要更新'mysql.slave_master_info'和
    'mysql.slave_relay_log_info'表所以需要跳过只读限制.
  */
  thd->set_skip_readonly_check();

  // 检查用户是否拥有SUPER或REPLICATION_SLAVE_ADMIN权限
  Security_context *sctx = thd->security_context();
  if (!sctx->check_access(SUPER_ACL) &&
      !sctx->has_global_grant(STRING_WITH_LEN("REPLICATION_SLAVE_ADMIN"))
           .first) {
    my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0),
             "SUPER or REPLICATION_SLAVE_ADMIN");
    return 1;
  }

...

// 获取正在运行中的复制线程
  init_thread_mask(&thread_mask, mi, false /* not inverse*/);

  /*
    如果用户指定了需要停止的复制线程，则把其他的复制线程标记为0（不停止）
  */
  if (thd->lex->slave_thd_opt) {
    thread_mask &= thd->lex->slave_thd_opt;

    // 停止IO线程时还需要考虑IO监控线程
    if ((thread_mask & SLAVE_IO) && mi->is_source_connection_auto_failover()) {
      thread_mask |= SLAVE_MONITOR;
    }
  } 
  // 停止复制线程
  if (thread_mask) {
    slave_errno =
        terminate_slave_threads(mi, thread_mask, rpl_stop_replica_timeout,
                                false /*need_lock_term=false*/);
  }

 /*
    STOP SLAVE的超时时间，从8.0.26开始新增了rpl_stop_replica_timeout
    参数，默认31536000s（365天）
  */
  ulong total_stop_wait_timeout = stop_wait_timeout;

  if (thread_mask & (SLAVE_SQL | SLAVE_FORCE_ALL)) {
    DBUG_PRINT("info", ("Terminating SQL thread"));
    
    // 标记需要终止SQL线程（加※）
    mi->rli->abort_slave = true;

    DEBUG_SYNC(current_thd, "terminate_slave_threads_after_set_abort_slave");

    // 停止SQL线程
    if ((error = terminate_slave_thread(
             mi->rli->info_thd, sql_lock, &mi->rli->stop_cond,
             &mi->rli->slave_running, &total_stop_wait_timeout,
             need_lock_term)) &&
        !force_all) {
      if (error == 1) {
        return ER_STOP_SLAVE_SQL_THREAD_TIMEOUT;
      }
      return error;
    }

 　　/*
      输盘Relay Log Info
    */
    if (mi->rli->flush_info(Relay_log_info::RLI_FLUSH_IGNORE_SYNC_OPT)) {
      return ER_ERROR_DURING_FLUSH_LOGS;
    }
......
if (thread_mask & (SLAVE_IO | SLAVE_FORCE_ALL)) {
    DBUG_PRINT("info", ("Terminating IO thread"));
    // 标记需要终止IO线程（加※）
    mi->abort_slave = true;

 // 终止IO线程
    if ((error = terminate_slave_thread(
             mi->info_thd, io_lock, &mi->stop_cond, &mi->slave_running,
             &total_stop_wait_timeout, need_lock_term, force_io_stop)) &&
        !force_all) {
      if (error == 1) {
        return ER_STOP_SLAVE_IO_THREAD_TIMEOUT;
      }
      return error;


    // 刷盘 Master Info
    if (!mi->is_gtid_only_mode()) {
      mysql_mutex_lock(&mi->data_lock);
      if (mi->flush_info(true)) {
        mysql_mutex_unlock(&mi->data_lock);
        mysql_mutex_unlock(log_lock);
        return ER_ERROR_DURING_FLUSH_LOGS;
      }
      mysql_mutex_unlock(&mi->data_lock);
    }
    // 输盘Relay Log Info
    if (mi->rli->relay_log.is_open() &&
        mi->rli->relay_log.flush_and_sync(true)) {
      mysql_mutex_unlock(log_lock);
      return ER_ERROR_DURING_FLUSH_LOGS;
    }

    mysql_mutex_unlock(log_lock);

  while (*slave_running)  // Should always be true
  {
    DBUG_PRINT("loop", ("killing slave thread"));

    mysql_mutex_lock(&thd->LOCK_thd_data);
    /*
      Error codes from pthread_kill are:
      EINVAL: invalid signal number (can't happen)
      ESRCH: thread already killed (can happen, should be ignored)
    */
#ifndef _WIN32
    // 给复制线程发送信号，判断线程是否存活
    int err [[maybe_unused]] = pthread_kill(thd->real_id, SIGALRM);
    assert(err != EINVAL);
#endif
    // 唤醒复制线程
    if (force)
      thd->awake(THD::KILL_CONNECTION);
    else
      thd->awake(THD::NOT_KILLED);
    mysql_mutex_unlock(&thd->LOCK_thd_data);

    DBUG_EXECUTE_IF("block_on_thread_stop_after_awake", {
      rpl_replica_debug_point(DBUG_RPL_R_WAIT_AFTER_AWAKE_ON_THREAD_STOP);
    });

    // 设置等待信号变量超时时间为2s
    struct timespec abstime;
    set_timespec(&abstime, 2);
#ifndef NDEBUG
    int error =
#endif
        // 等待复制线程STOP过的信号，每次等待2s超时
        mysql_cond_timedwait(term_cond, term_lock, &abstime);
    // 如果整个STOP操作超过了stop_wait_timeout，则操作超时
    if ((*stop_wait_timeout) >= 2)
      (*stop_wait_timeout) = (*stop_wait_timeout) - 2;
    else if (*slave_running) {
      if (need_lock_term) mysql_mutex_unlock(term_lock);
      return 1;
    }

// 判断mi->abort_slave

while (!io_slave_killed(thd, mi)) {
      MYSQL_RPL rpl;

      THD_STAGE_INFO(thd, stage_requesting_binlog_dump);
      if (request_dump(thd, mysql, &rpl, mi, &suppress_warnings) ||
          DBUG_EVALUATE_IF("simulate_reconnect_after_failed_binlog_dump", 1,
                           0)) {
        LogErr(ERROR_LEVEL, ER_RPL_SLAVE_ERROR_REQUESTING_BINLOG_DUMP,
               mi->get_for_channel_str());
        if (check_io_slave_killed(thd, mi,
                                  "Slave I/O thread killed while "
                                  "requesting master dump") ||
            try_to_reconnect(thd, mysql, mi, &retry_count, suppress_warnings,
                             reconnect_messages_after_failed_dump))
          goto err;
        goto connected;
      }
      const char *event_buf;

      assert(mi->last_error().number == 0);
      while (!io_slave_killed(thd, mi)) {
        ulong event_len;
        /*
           We say "waiting" because read_event() will wait if there's nothing to
           read. But if there's something to read, it will not wait. The
           important thing is to not confuse users by saying "reading" whereas
           we're in fact receiving nothing.
        */
        THD_STAGE_INFO(thd, stage_waiting_for_source_to_send_event);
        event_len = read_event(mysql, &rpl, mi, &suppress_warnings);
        if (check_io_slave_killed(thd, mi,
                                  "Slave I/O thread killed while "
                                  "reading event"))
          goto err;
          
          
 err:
    /*
      Note: the order of the two following calls (first broadcast, then unlock)
      is important. Otherwise a killer_thread can execute between the calls and
      delete the mi structure leading to a crash! (see BUG#25306 for details)
     */
　　// IO线程停止之后广播停止信号变量
    mysql_cond_broadcast(&mi->stop_cond);  // tell the world we are done
    DBUG_EXECUTE_IF("simulate_replica_delay_at_terminate_bug38694", sleep(5););
    mysql_mutex_unlock(&mi->run_lock);
  }