MySQL Page读取和淘汰过程分析

最新推荐文章于 2024-04-17 21:24:08 发布
最新推荐文章于 2024-04-17 21:24:08 发布
阅读量1k 收藏
点赞数 1
分类专栏： MySQL内核
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duxingxia356/article/details/101195054
版权

目录

Page磁盘读取过程

申请空闲PAGE空间

刷脏页和LRU链表

Page内存读取和Page淘汰的互斥

Page磁盘读取过程

buf_page_get_gen
|    | ==> rw_lock_s_lock(hash_lock);
|    | ==> block = (buf_block_t*) buf_page_hash_get_low(buf_pool, space, offset, fold);
|    | ==> if (block == NULL) rw_lock_s_unlock(hash_lock); 
|    | ==> //（MM）从存储读取PAGE到BP
|    | ==> buf_read_page(space, zip_size, offset)  
|        | ==> count = buf_read_page_low(&err, true, BUF_READ_ANY_PAGE, space,
    	                                 zip_size, FALSE, tablespace_version, offset);
|            | ==> //从BP中申请空闲page空间
|            | ==> bpage = buf_page_init_for_read(err, mode, space, zip_size, unzip, tablespace_version, offset);
|                | ==> block = NULL;
|                | ==> buf_pool_mutex_enter(buf_pool);
|                | ==> rw_lock_x_lock(hash_lock);
|                | ==> watch_page = buf_page_hash_get_low(buf_pool, space, offset, fold);
|                | ==> //释放了hashlock，还持有BP lock
|                | ==> rw_lock_x_unlock(hash_lock);
|                | ==> //申请空闲内存块
|                | ==> data = buf_buddy_alloc(buf_pool, zip_size, &lru);
|                    | ==> buf_buddy_alloc_low(buf_pool, buf_buddy_get_slot(size), lru));
|                        | ==> //从Free List中获取内存块
|                        | ==> block = buf_LRU_get_free_only(buf_pool);
|                        | ==> //free list中没有，从LRU中获取，此时要释放BP锁，因为从LRU获取过程中可能会休眠
|                        | ==> buf_pool_mutex_exit(buf_pool);
|                        |
|                        |
|                        | ==> block = buf_LRU_get_free_block(buf_pool);
|                        | ==> //标识从LRU链表中获取
|                        | ==> *lru = TRUE;
|                        | ==> //获取成功后重新加锁
|                        | ==> buf_pool_mutex_enter(buf_pool);
|                | ==> rw_lock_x_lock(hash_lock);
|                | ==> //如果从LRU获取的话，需要重新CHECK hash表中是否有该Page，因为获取过程中会释放BP MUTEX
|                | ==> /* If buf_buddy_alloc() allocated storage from the LRU list, it released and reacquired buf_pool->mutex.  Thus, we must check the page_hash again, as it may have been modified. */
|                | ==> if (UNIV_UNLIKELY(lru)) {
|                    | ==> watch_page = buf_page_hash_get_low(buf_pool, space, offset, fold);
|                | ==> if (watch_page && !buf_pool_watch_is_sentinel(buf_pool, watch_page)) rw_lock_x_unlock(hash_lock); watch_page = NULL; buf_buddy_free(buf_pool, data, zip_size);
|                | ==> //（MM）插入到HASH表
|                | ==> HASH_INSERT(buf_page_t, hash, buf_pool->page_hash, fold, bpage);
|                | ==> rw_lock_x_unlock(hash_lock);
|                | ==> //（MM）插入到LRU链表
|                | ==> buf_LRU_add_block(bpage, TRUE/* to old blocks */);
|                | ==> buf_pool_mutex_exit(buf_pool);
|    | ==> //增加引用计数
|    | ==> buf_block_fix(fix_block);
|        | ==> #ifdef PAGE_ATOMIC_REF_COUNT
|        | ==> 	os_atomic_increment_uint32(&block->page.buf_fix_count, 1);
|        | ==> #else
|        | ==> 	ib_mutex_t*	block_mutex = buf_page_get_mutex(&block->page);
|        | ==> 	mutex_enter(block_mutex);
|        | ==> 	++block->page.buf_fix_count;
|        | ==> 	mutex_exit(block_mutex);
|    | ==> rw_lock_s_unlock(hash_lock);
|    | ==> buf_wait_for_read(fix_block);

过程是：

  1. 对Page_Hash加s锁，判断是否存在。
  2. 如果不存在，释放s锁，加bp的互斥锁、加x锁。再次判断是否存在。
  3. 如果不存在，释放x锁，申请空闲Block。
  4. 然后加x锁，判断是否存在，如果不存在，插入空闲BLock。释放x锁
  5. 把block加入lru链表。释放bp的互斥锁。

步骤3释放x锁的原因是，线程持有bp的互斥锁，对lru\freelist的操作都依靠互斥锁。因此可以通过bp的互斥锁，阻塞其他线程申请空闲Block。但是在从Lru申请BLock过程中，可能出现由于休眠等待需要释放互斥锁，而导致其他线程进入，因此第4步根据空闲BLock的来源判断是否需要重新Check。

可以看到，从磁盘读取过程中，对hash的互斥成本是比较高的，加了2次x锁。这个地方后续版本中有优化。

申请空闲PAGE空间

buf_LRU_get_free_block
|    | ==> buf_pool_mutex_enter(buf_pool);
|    | ==> //（MM）从free_list中获取Page空间
|    | ==> block = buf_LRU_get_free_only(buf_pool);
|        | ==> UT_LIST_REMOVE(list, buf_pool->free, (&block->page));
|    | ==> //（MM）如果没有获取到，从LRU链表中获取非脏的PAGE空间
|    | ==> freed = buf_LRU_scan_and_free_block(buf_pool, n_iterations > 0);
|    | ==> //（MM）如果没有，从LLU刷一个脏页下去
|    | ==> buf_flush_single_page_from_LRU(buf_pool)



buf_LRU_scan_and_free_block(buf_pool, n_iterations > 0)
|    | ==> //尝试从解压缩页中获取空间
|    | ==> buf_LRU_free_from_unzip_LRU_list(buf_pool, scan_all)
|    | ==> //从LRU中获取非脏页面
|    | ==> buf_LRU_free_from_common_LRU_list(buf_pool, scan_all)
|        | ==> //从后向前遍历LRU链表
|        | ==> for (bpage = UT_LIST_GET_LAST(buf_pool->LRU), scanned = 1, freed = FALSE;
					bpage != NULL && !freed && (scan_all || scanned < srv_LRU_scan_depth); ++scanned) {
|        | ==> accessed = buf_page_is_accessed(bpage);
|        | ==> //尝试从LRU链表中转移一个PAGE到FREE LIST
|        | ==> freed = buf_LRU_free_page(bpage, true);
|            | ==> //判断页面是否有引用或者在IO过程中
|            | ==> if (!buf_page_can_relocate(bpage)) exit
|            | ==> //判断页面是否有修改
|            | ==> if (bpage->oldest_modification) exit
|            | ==> //从LRU链表中删除一条PAGE空间，如果是BUF_BLOCK_FILE_PAGE类型的PAGE，要在外面调用函数加入FREELIST
|            | ==> buf_LRU_block_remove_hashed(bpage, zip)
|                | ==> buf_LRU_remove_block(bpage);
|                    | ==> UT_LIST_REMOVE(LRU, buf_pool->LRU, bpage);
|                | ==> //从HASH表中删除
|                | ==> HASH_DELETE(buf_page_t, hash, buf_pool->page_hash, fold, bpage);
|            | ==> //把Page加入到FREE LIST
|            | ==> buf_LRU_block_free_hashed_page((buf_block_t*) bpage);
|                | ==> buf_LRU_block_free_non_file_page(block);
|                    | ==> memset
|                    | ==> UT_LIST_ADD_FIRST(list, buf_pool->free, (&block->page));
|        | ==> }



buf_flush_single_page_from_LRU(buf_pool)
|    | ==> for (bpage = UT_LIST_GET_LAST(buf_pool->LRU), scanned = 1;
				bpage != NULL;
				bpage = UT_LIST_GET_PREV(LRU, bpage), ++scanned) {
|    | ==> //判断页面是否有修改且是否在IO中
|    | ==> if (buf_flush_ready_for_flush(bpage, BUF_FLUSH_SINGLE_PAGE)
|    | ==> //刷脏页（同步IO）
|    | ==> buf_flush_page(buf_pool, bpage, BUF_FLUSH_SINGLE_PAGE, true);
|        | ==> buf_page_set_io_fix(bpage, BUF_IO_WRITE);
|        | ==> //如果是BUF_FLUSH_LIST，可能会走下面函数，此处有三个且条件
|        | ==> buf_dblwr_flush_buffered_writes();
|        | ==> buf_flush_write_block_low(bpage, flush_type, sync);
|            | ==> if (flush_type == BUF_FLUSH_SINGLE_PAGE) buf_dblwr_write_single_page(bpage, sync);
|                | ==> //持久化dblwr
|                | ==> fil_flush(TRX_SYS_SPACE);
|                | ==> //持久化数据页
|                | ==> buf_dblwr_write_block_to_datafile(bpage, sync);
|                    | ==> //调IO接口
|                    | ==> fil_io(flags, sync, buf_block_get_space(block), 0,
									buf_block_get_page_no(block), 0, UNIV_PAGE_SIZE,
									(void*) block->frame, (void*) block)
|                        | ==> //调AIO接口
|                        | ==> ret = os_aio(type, mode | wake_later, node->name, node->handle, buf, offset, len, node, message);
|                            | ==> os_aio_func
|                                | ==> //如果同步IO，读调用os_file_read_func，写调用os_file_write_func
|                                | ==> //如果异步IO，走异步IO系统
|                                | ==> os_aio_simulated_wake_handler_thread
|                        | ==> //如果是同步IO，进行IO_WAIT
|                        | ==> fil_node_complete_io(node, fil_system, type);
|            | ==> //关闭DBLWR场景
|            | ==> fil_io
|            | ==> //其他场景，通过dblwr持久化数据页
|            | ==> buf_dblwr_add_to_batch(bpage);
|            | ==> //同步IO场景，执行IO完成后操作
|            | ==> if (sync) {
|            | ==> fil_flush(buf_page_get_space(bpage));
|            | ==> buf_page_io_complete(bpage);
|                | ==> buf_flush_write_complete(bpage)
|                    | ==> //从FLU链表中移出
|                    | ==> buf_flush_remove(bpage);
|            | ==> }
|    | ==> }
|    | ==> //因为刚刷完脏页，重新遍历LRU链表，尝试把转移一个PAGE到FREE_LIST
|    | ==> ready = buf_flush_ready_for_replace(bpage);
|    | ==> freed = buf_LRU_free_page(bpage, evict_zip);

 

刷脏页和LRU链表

buf_flush_page_cleaner_thread
|    | ==> //依次遍历每个Buffer pool instance,从LRU尾部开始扫描，直到第srv_LRU_scan_depth个page停止，
|    | ==> //按批次刷LRU,每次期望刷100个page（PAGE_CLEANER_LRU_BATCH_CHUNK_SIZE), 每个Bp会进行srv_LRU_scan_depth/100次循环
|    | ==> buf_flush_LRU_tail
|        | ==> for (ulint i = 0; i < srv_buf_pool_instances; i++) {
|        | ==> scan_depth = UT_LIST_GET_LEN(buf_pool->LRU);
|        | ==> //LRU释放PAGE到FREE LIST
|        | ==> buf_flush_LRU(buf_pool, PAGE_CLEANER_LRU_BATCH_CHUNK_SIZE, &n_flushed)
|            | ==> buf_flush_start(buf_pool, BUF_FLUSH_LRU)
|            | 
|            |
|            | ==> buf_flush_batch(buf_pool, BUF_FLUSH_LRU, min_n, 0);
|                | ==> case BUF_FLUSH_LRU: buf_do_LRU_batch(buf_pool, min_n);
|                    | ==> if (buf_LRU_evict_from_unzip_LRU(buf_pool)) buf_free_from_unzip_LRU_list_batch(buf_pool, max);
|                    | ==> //
|                    | ==> buf_flush_LRU_list_batch(buf_pool, max - count);
|                        | ==> //没有引用、没有IO、没有变更
|                        | ==> evict = buf_flush_ready_for_replace(bpage);
|                        | ==> //尝试从LRU链表中转移PAGE到FREE LIST
|                        | ==> if (evict) buf_LRU_free_page(bpage, true);
|                        | ==> //把这个PAGE持久化
|                        | ==> else buf_flush_page_and_try_neighbors(bpage, BUF_FLUSH_LRU, max, &count);
|                            | ==> //判断这个PAGE是否需要持久化
|                            | ==> buf_flush_ready_for_flush(bpage, flush_type)
|                            | ==> //持久化这个PAGE
|                            | ==> buf_flush_try_neighbors(space, offset, flush_type, *count, n_to_flush)
|                                | ==> buf_flush_page(buf_pool, bpage, flush_type, false)
|            | ==> buf_flush_end(buf_pool, BUF_FLUSH_LRU);
|        | ==> }
|    | ==> //判断是需要刷脏页
|    | ==> page_cleaner_flush_pages_if_needed
|        | ==> //number of pages thatwe should attempt to flush, LSN up to which flushing must happen
|        | ==> page_cleaner_do_flush_batch(ulint n_to_flush, lsn_t lsn_limit)
|            | ==> buf_flush_list(n_to_flush, lsn_limit, &n_flushed);
|                | ==> //依次为每个BP执行
|                | ==> buf_flush_batch(buf_pool, BUF_FLUSH_LIST, min_n, lsn_limit)
|                    | ==> count = buf_do_flush_list_batch(buf_pool, min_n, lsn_limit);
|                        | ==> //从FLU链表的尾部开始遍历，跳出条件时候刷脏的PAGE数量和LSN
|                        | ==> buf_flush_set_hp(buf_pool, prev);
|                        | ==> buf_flush_list_mutex_exit(buf_pool);
|                        | ==> buf_flush_page_and_try_neighbors(bpage, BUF_FLUSH_LIST, min_n, &count);
|                        | ==> buf_flush_list_mutex_enter(buf_pool);
|                        | ==> buf_flush_is_hp(buf_pool, prev)

 

Page内存读取和Page淘汰的互斥

buf_flush_batch
|    | ==> //加LRU LOCK
|    | ==> buf_pool_mutex_enter(buf_pool);
|    | ==> count = buf_do_LRU_batch(buf_pool, min_n);
|        | ==> buf_flush_LRU_list_batch(buf_pool, max - count);
|            | ==> bpage = UT_LIST_GET_LAST(buf_pool->LRU);
|            | ==> mutex_enter(block_mutex);
|            | ==> evict = buf_flush_ready_for_replace(bpage);
|                | ==> bpage->buf_fix_count == 0
|            | ==> mutex_exit(block_mutex);
|            | ==> if (evict) buf_LRU_free_page
|                | ==> rw_lock_x_lock(hash_lock);
|                | ==> mutex_enter(block_mutex);
|                | ==> //重新判断引用计数
|                | ==> buf_page_can_relocate
|                | ==> //从LRU和HASH表删除
|                | ==> buf_LRU_block_remove_hashed
|                    | ==> buf_LRU_remove_block(bpage);
|                    | ==> HASH_DELETE(buf_page_t, hash, buf_pool->page_hash, fold, bpage);
|                    | ==> rw_lock_x_unlock(hash_lock);
|                | ==> buf_pool_mutex_exit(buf_pool);
|                | ==> buf_pool_mutex_enter(buf_pool);
|                | ==> buf_LRU_block_free_hashed_page((buf_block_t*) bpage);
|                    | ==> buf_LRU_block_free_non_file_page(block);
|                        | ==> UT_LIST_ADD_FIRST(list, buf_pool->free, (&block->page));
|    | ==> buf_pool_mutex_exit(buf_pool);

Page淘汰过程如下：

  • 加BP的互斥锁
  • 从LRU链表的获取最老的数据页
  • 确认Page是否可以被淘汰
  • 如果可以淘汰，加hash_page的x锁，此时重新判断，因为前述判断无法拦截对Page的访问，因此此时对Page_hash加x锁，进行准确的判断。
  • 如果确实可以淘汰，从Page_Hash中删除，释放hash的x锁。
  • 将Page加入空闲链表

 

西门仙忍
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring事务理解和配置
Student108的博客
09-07 2462
文章目录1 Spring事务1.1 事务简介1.1.1 什么是事务1.1.2 事物的特性1.1.3 不考虑事物会引发的安全问题1.1.4 事务隔离级别1.2 事务的传播行为1.3 编程式事务(需要手动写代码,了解)1.3.1 配置平台事务管理器1.3.2 Spring提供了事务管理的模板类1.3.3 在业务层注入事务管理的模板1.3.4 编写事务管理的代码1.4 声明式事务(xml配置)1.4.1 配置事务管理器1.4.2 配置增强1.4.3 AOP的配置1.5 声明式事务(注解)1.5.1 配置事务管理器
60 个知识点带你轻松掌握 MySQL
qwer123451234123的博客
05-11 551
1、关系型和非关系型数据库的区别？ 关系型数据库的优点 容易理解，因为它采用了关系模型来组织数据。 可以保持数据的一致性。 数据更新的开销比较小。 支持复杂查询（带 where 子句的查询） 非关系型数据库（NOSQL）的优点 无需经过 SQL 层的解析，读写效率高。 基于键值对，读写性能很高，易于扩展 可以支持多种类型数据的存储，如图片，文档等等。 扩展（可分为内存性数据库以及文档型数据库，比如 Redis，MongoDB，HB
【MySQL 数据宝典】【内存结构】- 002 Page管理机制
最新发布
黄金时代的架构之路
04-17 958
Buffer Pool 的底层采用链表数据结构管理Page。在InnoDB访问表记录和索引时会在Page页中缓存，以后使用可以减少磁盘IO操作，提升效率。
mysql 性能优化——磁盘刷脏页性能优化
擅长后端研发
03-10 1196
大家是不是感觉mysql 更新挺快的呀，有没有想过mysql 更新为什么那么快。按道理说，mysql 更新都是先找到这一行数据，然后在去更新。意味着，就有两次磁盘操作，一个是磁盘读，一个是磁盘写。如果真的是这样的话，肯定会很慢呀，mysql 也没有那么傻。当有一条记录需要更新的时候，InnoDB 引擎就会先把记录写到 redo log 里面，并更新内存，这个时候更新就算完成了。同时，InnoDB 引擎会在适当的时候，将这个操作记录更新到磁盘里面。
《MySQL实战45讲》——学习笔记12 “InnoDB刷脏页的控制策略“
娜娜米的博客
11-06 1541
12 | 为什么我的MySQL会“抖”一下？
MYSQL系列4-刷脏
ilwoziji的博客
03-19 225
将内存数据页保存至磁盘。同时，删除与此页相关的redo log，推进check point。刷脏可能会大致Mysql卡住，造成性能问题。通过告知服务器IO性能，可以控制合理刷脏IO。合理的脏页比例上限，建议保持默认。“顺便刷脏”功能需要在SSD硬盘下关闭。
php调用mysql存储过程实例分析
10-24
主要介绍了php调用mysql存储过程,综合各种常见实例分析了php调用mysql存储过程的各种常见操作与使用技巧,具有一定的参考借鉴价值,需要的朋友可以参考下
MySQL 声明变量及存储过程分析
09-09
主要介绍了MySQL 声明变量及存储过程的相关内容，小编觉得挺不错的，这里分享给大家，需要的朋友可以参考下。
mysql存储过程用法实例分析
09-09
主要介绍了mysql存储过程用法,结合实例形式简单分析了mysql存储过程的概念、功能、定义、执行、调用等相关操作技巧,需要的朋友可以参考下
易语言MySql图片读取
03-24
"中国农业银行.jpg"是压缩包内的图片文件，可以作为测试数据，用于演示如何使用易语言将图片存入和从MySQL数据库中读取。在实际操作中，你需要使用易语言的"文件"模块读取这个图片文件，然后将读取到的二进制数据...
VB读CSV到mysql_VB读取CSV到mysql_源码
09-30
标题中的"VB读CSV到mysql"指的是使用Visual Basic (VB)编程语言来读取CSV（逗号分隔值）文件，并将数据导入到MySQL数据库的过程。这是一个常见的数据迁移任务，特别是在处理大量结构化数据时。VB是Microsoft开发的一...
MySQL如何高效实现刷脏页，了解原理并学会配置
杨荧的CSDN博客
09-04 2038
在MySQL中，刷脏页是指将内存中已被修改的数据页写回到磁盘的过程。当MySQL执行数据更新操作时，会将修改后的数据先写入内存的缓存区，然后通过后台线程将这些脏页定期或根据一定策略写回到磁盘上的数据文件。
Mysql - 脏页刷新机制
it_lihongmin的博客
04-07 2232
而当内存中的数据页与磁盘中的不一致时该数据页叫作脏页，当执行flush操作将磁盘页数据页和内存数据页进行合并之后，内存和磁盘的数据页相同，则称为干净页
mysql数据落盘详解_MySQL的Flush-List和脏页的落盘机制
weixin_33365481的博客
01-28 783
一、回顾mysql启动后buffer pool会初始化。buffer pool也会初始化好n多个空白的缓存页，以及它们的描述数据会被组织成lru链表以及freelist 双向链表。这时你从磁盘中读取一个数据页，会先从free list中找出一个空闲缓存页的描述信息，然后将你读出的数据页中加载进缓存页中。同时将缓存页的描述信息从free list中剔除，此外该描述信息块还会被维护进lru链表中。数据...
MySQL的刷脏页策略
qq_48157004的博客
09-12 3740
当内存数据页跟磁盘数据页内容不一致的时候，我们称这个内存页为“脏页”。 1.当我们修改一条数据时，如果数据在内存中，我们是先会去改内存的，而不是先去改磁盘。假如数据都在内存中，这时候断电了怎么办，服务器宕机怎么办，这个时候就需要我们的redo log了。 在每一条数据更新时，MySQL会先写redo log日志，在去写binlog 日志。在写这两个日志过程中会涉及到**两阶段提交**。他可以保证两个日志逻辑上的一致性。所以即使因为停电，宕机等原因，MySQL也可以通过redo log将数据进行恢复。
MySQL:buffer cache 刷脏
Lixora's DB Home
11-14 75
刷盘写入数据文件由DBLWR部分完成，为异步IO，异步IO主要为前台thread 发起io_submit，后台异步IO线程堵塞等待结果，然后处理完成的一些动作，比如检查page的IO状态，数据文件的fsync操作，刷盘后一个更加重要的动作是异步IO线程还要完成内存的维护，比如对于flush list刷脏需要从flush list链表中删除，对于lru刷脏则额外还需要从page的hash结构和LRU链表中删除并且返回给free list成为可用的空闲page。下面是一些主要流程供参考，
（五）大白话MySQL的Buffer Pool的free链表、flush链表、LRU链表
zht245648124的博客
10-03 1942
MySQL的Buffer Pool的free链表、flush链表、LRU链表
Mysql中Page(页)和结构的认识
kitonGao的博客
07-19 1667
文章目录一、Page——页一、Page Directory（记录在页中的展现）二、B数 & B+树一、B树和B+树的区别三、Index——索引1、聚簇索引——主键2、二级索引——非主键缓冲池——Buffer Pool总结 一、Page——页 为了避免一条提条的读取磁盘的数据，InnoDB采取页的方式，作为磁盘和内存之间交互的基本方式 一个页的大小一般是16KB InnoDB为了不同的目的而设计了多种不同类型的页： 1、存放表空间头部信息的页 2、粗放undo日志信息的页等… 把存放表中数
mysql page_一文理解MySQL中的page页
weixin_26786277的博客
01-18 2362
在介绍InnoDB中的页的时候，很有必要先让大家了解一下InnoDB中的存储结构从InnoDB存储引擎的逻辑结构看，所有数据都被逻辑地存放在一个空间内，称为表空间(tablespace)，而表空间由段(sengment)、区(extent)、页(page)组成。 在一些文档中extend又称块(block)。一、表空间(table space)表空间(Tablespace)是一个逻辑容器，表空间存...
mongodb 和mysql 异步读取对比
03-02
MongoDB和MySQL都支持异步读取。但是它们的异步读取机制不同。 在MongoDB中，使用异步读取可以通过查询选项来启用。当使用异步读取时，查询将不会阻塞调用线程，而是返回一个游标对象。可以在任何时候读取游标对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值