MySQL中Innodb page clean线程分析

共计 10661 个字符，预计需要花费 27 分钟才能阅读完成。

这篇文章主要讲解了“MySQL 中 Innodb page clean 线程分析”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着丸趣 TV 小编的思路慢慢深入，一起来研究和学习“MySQL 中 Innodb page clean 线程分析”吧！

一、数据结构和入口函数 1、数据结构

page_cleaner_t：整个 Innodb 只有一个，包含整个 page clean 线程相关信息。其中包含了一个 page_cleaner_slot_t 的指针。

变量名含义 mutex 用于保护整个 page_cleaner_t 结构体和 page_cleaner_slot_t 结构体，当需要修改结构体信息的时候需要获取这个 mutex，如在 pc_request 函数中 is_requested 一个条件变量，用于唤醒堵塞在这个条件之上的工作线程 is_finished 一个条件变量，用于通知协调线程刷新工作已经完成 n_workers 当前存在的工作线程总数 requested 布尔值，当前是否需要进行脏数据刷新工作 lsn_limit 需要刷新到 lsn 的位置，当需要同步刷新的时候，这个值将被赋予，以保证小于这个 lsn 的日志都已经完成了刷盘工作 n_slots 槽的数量，槽的数量和 buffer instance 的数量相同 n_slots_requested 当前处于需要刷新状态下 (PAGE_CLEANER_STATE_REQUESTED) 的槽的数量 n_slots_flushing 当前处于刷新状态下 (PAGE_CLEANER_STATE_FLUSHING) 的槽的数量 n_slots_finished 当前处于已经刷新完成状态下 (PAGE_CLEANER_STATE_FINISHED) 的槽的数量 flush_time 整个 (以 innodb buffer 为单位) 刷新消耗的时间（累计 page_cleaner- flush_time += ut_time_ms() – tm;）flush_pass 整个 (以 innodb buffer 为单位) 刷新的次数（累计 page_cleaner- flush_pass++;）slots 指针指向实际的槽 is_running 布尔值，如果关闭 innodb 会被设置为 false，进行强行刷新脏数据

page_cleaner_slot_t：每个 buffer instance 都包含一个这样的结构体，page clean 工作线程刷新的时候每个线程都会轮询的检测每个槽，知道找到没有被其他 page clean 线程刷新的槽进行刷新工作，直到每个槽（buffer instance）都刷新完成。参考 pc_flush_slot 函数。

变量名含义 state 状态 PAGE_CLEANER_STATE_REQUESTED、PAGE_CLEANER_STATE_FLUSHING 和 PAGE_CLEANER_STATE_FINISHED 中的一种 n_pages_requested 本槽需要刷新的总的块数量 n_flushed_list 已经刷新的块数 succeeded_list 布尔值，刷新是否完成 flush_list_time 本槽刷新消耗的时间（累计参考 pc_flush_slot 函数）flush_list_pass 本槽进行刷新操作的次数（累计参考 pc_flush_slot 函数）2、入口函数

协调工作线程入口：buf_flush_page_cleaner_coordinator

工作线程入口：buf_flush_page_cleaner_worker

二、主循环解析

其由函数 buf_flush_page_cleaner_coordinator 实现。实际正常运行情况下的工作都包含在 while (srv_shutdown_state == SRV_SHUTDOWN_NONE) 这个大循环下。

1、是否需要睡眠 1 秒判断

首先如果没有活跃的 change buffer 并且没有 pending 的物理块，并且上次刷新的块数量为 0
则不需要睡眠 1 秒：

if (srv_check_activity(last_activity) 
 || buf_get_n_pending_read_ios() || n_flushed == 0){
 ret_sleep = pc_sleep_if_needed( next_loop_time, sig_count); // 睡眠一秒  if (srv_shutdown_state != SRV_SHUTDOWN_NONE) { break;
 }
 } else if (ut_time_ms()   next_loop_time) { // 如果当前时间大于   上次刷新   时间 +1  秒则   设置为 OS_SYNC_TIME_EXCEEDED
 ret_sleep = OS_SYNC_TIME_EXCEEDED; 
 } else {
 ret_sleep = 0;
 }

但是这个睡眠是可以被唤醒的，比如同步刷新应该就会唤醒它（buf_flush_request_force 函数）。参考函数 os_event::wait_time_low

2、IO 能力不足警告

如前文所描述这里产生如下警告：

page_cleaner: 1000ms intended loop took **ms. The settings might not be optimal.((flushed= **  , during the time.)

源码片段：

if (curr_time   next_loop_time + 3000) { // 如果刷新时间   大于了   上次时间  +1  秒 +3  秒   则报 info
 if (warn_count == 0) { ib::info()    page_cleaner: 1000ms 
   intended loop took  
   1000 + curr_time
 - next_loop_time
    ms. The settings might not 
   be optimal. (flushed= 
   n_flushed_last
    , during the time.)  if (warn_interval   300) {
 warn_interval = 600;
 } else {
 warn_interval *= 2;
 }

3、同步刷新判断

触发条件

(ret_sleep != OS_SYNC_TIME_EXCEEDED
   srv_flush_sync
   buf_flush_sync_lsn   0)

同步会唤醒正在睡眠状态的 page clean 协调工作线程那么睡眠应该不会满足一秒的条件所以不会被标记为 OS_SYNC_TIME_EXCEEDED，同时 srv_flush_sync 和 buf_flush_sync_lsn 均会被设置接下来就是唤醒工作线程进行刷新，同时本协调线程也完成部分任务。

工作代码

 pc_request(ULINT_MAX, lsn_limit); // 唤醒 page clean  工作线程干活
 /* Coordinator also treats requests */ // 协调者同样要完成部分任务
 while (pc_flush_slot()   0) {}

唤醒操作

如前文描述在 checkpoint 或者 DML 语句执行过程中都会通过 log_free_check 检查是否 redo log 处于安全的状态，如果不安全就会调用如下代码（log_preflush_pool_modified_pages 函数中）唤醒 page clean 线程进行同步刷新：

if (srv_flush_sync) { /* wake page cleaner for IO burst */
 buf_flush_request_force(new_oldest); // 设置全局变量同时通过 broadcast 唤醒同步刷新
 }
 buf_flush_wait_flushed(new_oldest); // 所有线程等待同步刷新完成

4、活跃刷新

触发条件

srv_check_activity(last_activity)

这里判断是否有活跃的线程，所谓活跃就是调用 srv_inc_activity_count 函数进行增加的，一般来讲 DML 和 DDL 会标记为活跃，purge 线程及其工作线程工作期间会标记为活跃。可以将断点做到 srv_inc_activity_count 进行 debug。所以线上数据库 DML 比较多所以一般都会是活跃刷新。

工作代码

这里涉及到刷新多少个块计算主要函数为 page_cleaner_flush_pages_recommendation，后面在讨论。

n_to_flush = page_cleaner_flush_pages_recommendation(lsn_limit, last_pages);// 此处 n_to_flush 就是本次需要刷新的块数的数量 pc_request(n_to_flush, lsn_limit); // 唤醒 page clean  工作线程干活 /* Coordinator also treats requests */ // 工作协调线程同样要完成部分任务
 while (pc_flush_slot()   0) {}
pc_wait_finished(n_flushed_list);// 等待其他刷新完成

5、空闲刷新

触发条件

else if (ret_sleep == OS_SYNC_TIME_EXCEEDED)

当睡足了 1 秒，并且没有活跃的线程。那么就进行空闲刷新，一般来讲如果没有 DML/DDL 等语句那么应该进行是空闲刷新。

工作代码

buf_flush_lists(PCT_IO(100), LSN_MAX,  n_flushed); //io 能力   刷新到那个 lsn  以及传出刷新的块数量 //PCT_IO 是一个宏如下：#define PCT_IO(p) ((ulong) (srv_io_capacity * ((double) (p) / 100.0)))

可以看到这里的百分比直接是 100% 及按照 innodb_io_capacity 参数的设定进行刷新。

当然这里只是看了正常期间工作的代码，如果是 Innodb shutdown 也会触发同步刷新。可自行参考代码。

三、page_cleaner_flush_pages_recommendation 函数

前面提过这个函数，是活跃刷新刷新块的计算函数，下面直接给出整个代码

{ cur_lsn = log_get_lsn();// 获取当前的 lsn  在  redo buffer 中的
 if (prev_lsn == 0) { // 静态变量如果是 0 则代表是第一次执行本函数
 /* First time around. */
 prev_lsn = cur_lsn;
 prev_time = ut_time(); // 获取当前时间
 return(0);
 } if (prev_lsn == cur_lsn) { // 如果没有 redo 日志生成
 return(0);
 }
 sum_pages += last_pages_in; time_t curr_time = ut_time(); double time_elapsed = difftime(curr_time, prev_time);
 avg_page_rate = static_cast ulint ( ((static_cast double (sum_pages)
 / time_elapsed)
 + avg_page_rate) / 2); // 算出上次刷新每秒刷新的 pages 数量，同时加上次计算的每秒平均刷新块数   然后除以 2   得到一个每秒刷新的 pages 数量  ！！！第一个计算条件 avg_page_rate  生成
 /* How much LSN we have generated since last call. */
 lsn_rate = static_cast lsn_t ( static_cast double (cur_lsn - prev_lsn)
 / time_elapsed);// 计算 redo lsn 生成率
 lsn_avg_rate = (lsn_avg_rate + lsn_rate) / 2;// 计算 redo 每秒平均生成率
 /* aggregate stats of all slots */
 mutex_enter(page_cleaner- mutex);
 ulint flush_tm = page_cleaner- flush_time;
 ulint flush_pass = page_cleaner- flush_pass;
 page_cleaner- flush_time = 0;
 page_cleaner- flush_pass = 0;
 ulint list_tm = 0;
 ulint list_pass = 0; for (ulint i = 0; i   page_cleaner- n_slots; i++) {// 扫描所有的槽
 page_cleaner_slot_t* slot;
 slot =  page_cleaner- slots[i];
 list_tm += slot- flush_list_time;
 list_pass += slot- flush_list_pass;
 slot- flush_list_time = 0;
 slot- flush_list_pass = 0;
 }
 mutex_exit(page_cleaner- mutex);
 oldest_lsn = buf_pool_get_oldest_modification(); // 获取 flush list 中最老的 ls
 ut_ad(oldest_lsn  = log_get_lsn());// 断言
 age = cur_lsn   oldest_lsn ? cur_lsn - oldest_lsn : 0; // 获取当前 LSN 和最老 LSN 的之间的差值
 pct_for_dirty = af_get_pct_for_dirty(); // 计算出一个刷新百分比  (比如 100) !!!! 重点
 pct_for_lsn = af_get_pct_for_lsn(age);// 计算出 lsn 的比率   百分比(l 列如 4.5) 
 pct_total = ut_max(pct_for_dirty, pct_for_lsn);// 取他们的大值
 
 /* Estimate pages to be flushed for the lsn progress */// 计算 target_lsn
 ulint sum_pages_for_lsn = 0; lsn_t target_lsn = oldest_lsn
 + lsn_avg_rate * buf_flush_lsn_scan_factor; // 计算下一次刷新的   目标 lsn  及 target_lsnbuf_flush_lsn_scan_factor 是定值 3
 for (ulint i = 0; i   srv_buf_pool_instances; i++) {// 循环整个 buffer instance 找到小于 target_lsn 的脏块
 buf_pool_t* buf_pool = buf_pool_from_array(i);
 ulint pages_for_lsn = 0;
 buf_flush_list_mutex_enter(buf_pool); for (buf_page_t* b = UT_LIST_GET_LAST(buf_pool- flush_list);// 每个 innodb buffer 的末尾的 flush list  进行扫描，头插法?
 b != NULL;
 b = UT_LIST_GET_PREV(list, b)) { if (b- oldest_modification   target_lsn) { break;
 }
 ++pages_for_lsn; // 某个  innodb buffer  实例中  flush list  小于这个  target lsn  的  page 计数
 }
 buf_flush_list_mutex_exit(buf_pool);
 sum_pages_for_lsn += pages_for_lsn; // 这里汇总所有  innodb buffer 实例中  flush list  小于这个  target lsn  的  page  总数
 mutex_enter(page_cleaner- mutex);
 ut_ad(page_cleaner- slots[i].state
 == PAGE_CLEANER_STATE_NONE);// 断言所有的槽处于没有刷新状态
 page_cleaner- slots[i].n_pages_requested
 = pages_for_lsn / buf_flush_lsn_scan_factor + 1; // 确认槽的 n_pages_requested 值
 mutex_exit(page_cleaner- mutex);
 }
 sum_pages_for_lsn /= buf_flush_lsn_scan_factor;//buf_flush_lsn_scan_factor 为定值 3
 /* Cap the maximum IO capacity that we are going to use by
 max_io_capacity. Limit the value to avoid too quick increase */
 n_pages = PCT_IO(pct_total); // 根据   前面得到的  pct_total  和  srv_io_capacity 参数得到   刷新的块数  !!! 第二个计算参数生成。 if (age   log_get_max_modified_age_async()) { // 如果日质量小于   异步刷新的范畴
 ulint pages_for_lsn = std::min ulint (sum_pages_for_lsn,
 srv_max_io_capacity * 2); // 即便是需要刷新的块数很多，最多只能刷 max_io_capacity* 2 的数量!!! 第三个计算参数生成
 n_pages = (n_pages + avg_page_rate + pages_for_lsn) / 3; // 3 部分组成  1、根据参数计算出来的 IO 能力  2、以往每秒刷新页的数量  3、根据 target lsn  计算出来的一个需要刷新的块数
 } if (n_pages   srv_max_io_capacity) {
 n_pages = srv_max_io_capacity;
 } return(n_pages);
}

此函数最后计算出了需要刷新的块，其中刷新比率计算的的重点函数为 af_get_pct_for_dirty 和 af_get_pct_for_lsn 下面将给出代码注释，其实前文中的算法就来自 af_get_pct_for_dirty。

四、af_get_pct_for_dirty 和 af_get_pct_for_lsn 函数

af_get_pct_for_dirty 函数

 double dirty_pct = buf_get_modified_ratio_pct(); // 得到   修改的块 / 总的块的   的百分比   记住脏数据比率
 if (dirty_pct == 0.0) { /* No pages modified */
 return(0);
 }
 ut_a(srv_max_dirty_pages_pct_lwm
  = srv_max_buf_pool_modified_pct); if (srv_max_dirty_pages_pct_lwm == 0) { // 如果 innodb_max_dirty_pages_pct_lwm 没有设置
 /* The user has not set the option to preflush dirty
 pages as we approach the high water mark. */
 if (dirty_pct  = srv_max_buf_pool_modified_pct) { // 如果脏数据比率大于了 innodb_max_dirty_pages_pct 则返回比率 100%
 /* We have crossed the high water mark of dirty
 pages In this case we start flushing at 100% of
 innodb_io_capacity. */
 return(100);
 }
 } else if (dirty_pct  = srv_max_dirty_pages_pct_lwm) { // 如果设置了 innodb_max_dirty_pages_pct_lwm  并且脏数据比率大于了
 /* We should start flushing pages gradually. */ //innodb_max_dirty_pages_pct_lwm 参数设置
 return(static_cast ulint ((dirty_pct * 100)
 / (srv_max_buf_pool_modified_pct + 1))); // 则返回  (脏数据比率 /(innodb_max_dirty_pages_pct+1))*100  也是一个比率   如(45/76)*100
 } return(0);// 否则返回 0 

af_get_pct_for_lsn 函数：

注意 innodb_cleaner_lsn_age_factor 参数默认设置为 high_checkpoint，可以看到算法最后是除以 700.5，所有前文我说这个函数算出来的比率一般比较小。

 lsn_t af_lwm = (srv_adaptive_flushing_lwm
 * log_get_capacity()) / 100;// srv_adaptive_flushing_lwm=10  那么大约就是  logtotalsize*(9/10)*(1/10) 943349  计算一个 low water mark
 if (age   af_lwm) { // 如果当前生成的 redo  小于了  low water master  则返回 0   也就是说  redo 日志量生成量不高则不需要权衡
 /* No adaptive flushing. */ // 可以看出这里和 redo 设置的大小有关，如果 redo 文件设置越大则 af_lwm 越大，触发权衡的机率越小
 return(0);
 }
 max_async_age = log_get_max_modified_age_async(); // 获取需要异步刷新的的位置   大约为 logtotalsize*(9/10)*(7/8)
 if (age   max_async_age   !srv_adaptive_flushing) { // 如果小于异步刷新   且   自适应 flush  没有开启
 /* We have still not reached the max_async point and
 the user has disabled adaptive flushing. */
 return(0);
 } /* If we are here then we know that either:
 1) User has enabled adaptive flushing
 2) User may have disabled adaptive flushing but we have reached
 max_async_age. */
 lsn_age_factor = (age * 100) / max_async_age; // 比率 lsn_age_factor = (本次刷新的日志量 /(logtotalsize*(9/10)*(7/8)))
 ut_ad(srv_max_io_capacity  = srv_io_capacity); 
 switch ((srv_cleaner_lsn_age_factor_t)srv_cleaner_lsn_age_factor) { case SRV_CLEANER_LSN_AGE_FACTOR_LEGACY: return(static_cast ulint ( ((srv_max_io_capacity / srv_io_capacity)
 * (lsn_age_factor
 * sqrt((double)lsn_age_factor)))
 / 7.5)); //430
 case SRV_CLEANER_LSN_AGE_FACTOR_HIGH_CHECKPOINT: //innodb_cleaner_lsn_age_factor 参数默认设置为 high_checkpoint
 return(static_cast ulint ( 
 ((srv_max_io_capacity / srv_io_capacity) // ((max_io_cap /io_cap) * (sqrt(lsn_age_factor)*lsn_age_factor*lsn_age_factor))/700.5
 * (lsn_age_factor * lsn_age_factor //(10 * (3.3*10*10))/700 =4.3
 * sqrt((double)lsn_age_factor)))
 / 700.5)); //

感谢各位的阅读，以上就是“MySQL 中 Innodb page clean 线程分析”的内容了，经过本文的学习后，相信大家对 MySQL 中 Innodb page clean 线程分析这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是丸趣 TV，丸趣 TV 小编将为大家推送更多相关知识点的文章，欢迎关注！