<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Bravoboy</title>
    <description>blog &amp; blog theme copy from</description>
    <link>https://bravoboy.github.io/</link>
    <atom:link href="https://bravoboy.github.io/feed.xml" rel="self" type="application/rss+xml"/>
    <pubDate>Tue, 17 Sep 2024 02:21:42 +0000</pubDate>
    <lastBuildDate>Tue, 17 Sep 2024 02:21:42 +0000</lastBuildDate>
    <generator>Jekyll v3.10.0</generator>
    
      <item>
        <title>mysql8.0 autoinc 重复排查</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#问题背景&quot; id=&quot;markdown-toc-问题背景&quot;&gt;问题背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#排查过程&quot; id=&quot;markdown-toc-排查过程&quot;&gt;排查过程&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#分析问题&quot; id=&quot;markdown-toc-分析问题&quot;&gt;分析问题&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#代码解析&quot; id=&quot;markdown-toc-代码解析&quot;&gt;代码解析&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#验证猜测&quot; id=&quot;markdown-toc-验证猜测&quot;&gt;验证猜测&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#解决方案&quot; id=&quot;markdown-toc-解决方案&quot;&gt;解决方案&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;问题背景&quot;&gt;问题背景&lt;/h2&gt;
业务在线上数据库里面偶然发现有部分数据，刚insert插入，然后select出来发现值和自己入的对不上。业务逻辑里面并没有update操作，解析mysql binlog文件，发现数据确实是被update更新过了，数据库版本是mysql8.0。那么这个update操作到底是哪里来的？

&lt;h2 id=&quot;排查过程&quot;&gt;排查过程&lt;/h2&gt;
&lt;h4 id=&quot;分析问题&quot;&gt;分析问题&lt;/h4&gt;
简化一下表结构，创建下面t1表，其中id是主键，并且是自增值，存储引擎是innodb
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;create table t1 (
id in not null auto_increment,
name varchar(1024),
age int,
primary key(id)) engine = innodb
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
insert sql语句
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;insert into t1 (id, name, age) values (...) on duplicate update age = values(age)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
除了insert语句，并没有其他的update语句，看到sql语句，那么可以猜测走到on duplicate update逻辑里面了。但是这个表里面除了id主键以外，没有其他unique的索引，那么只能是id重复冲突了，问题就变成了auto_increment字段为什么会重复冲突。

&lt;h4 id=&quot;代码解析&quot;&gt;代码解析&lt;/h4&gt;
先大致梳理一下innodb插入数据的过程
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;1. 先调用update_auto_increment获取autoinc值，更新table-&amp;gt;autoinc
2. 再调用row_insert_for_mysql插入数据
3. 最后调用set_max_autoinc尝试更新table-&amp;gt;autoinc
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
第一步分配autoinc值是要对table-&amp;gt;autoinc_mutex加锁，保证并发的插入的时候不会分配出来重复的id。&lt;br /&gt;
第二步row_insert_for_mysql里面会有duplicate key检查。&lt;br /&gt;
那么按理说不会出现autoinc重复的问题。再次翻看业务的sql语句发现有一些insert里面id字段对应的是null，有一些insert语句id字段对应的值不是null，是用户传入的一个值。
对于传入null字段，系统是会自动分配递增的autoinc &lt;br /&gt;
如果是用户传入了一个id值，系统就不会再分配了，所以猜测问题是用户传入的值和系统分配的值冲突了，导致触发了update逻辑 &lt;br /&gt;

&lt;h2 id=&quot;验证猜测&quot;&gt;验证猜测&lt;/h2&gt;
假设当前表的autoinc值最大值是2，下一个分配的值是3，用2个session同时插入数据证实我的猜测
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;session1插入insert into t1 (id, name, age) values (null, ‘c’, 3);
session2插入insert into t1 (id, name, age) values (3, ‘cc’, 33);
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
需要使用gdb调试多线程，网上资料很多，我就不再赘述。然后在ha_innobase::write_row函数开始加断点。这里我们可以观察到2个session都在卡在断点。
&lt;ol&gt;
  &lt;li&gt;我们先让session2执行，因为自带了id值，所以不需要系统分配，执行完row_insert_for_mysql，观察返回值err，发现是成功的。&lt;/li&gt;
  &lt;li&gt;再然后我们让session1执行，在第一步系统分配出来的autoinc值确实就是3，在执行row_insert_for_mysql前切回到session2线程&lt;/li&gt;
  &lt;li&gt;我们让session2继续执行，释放锁。&lt;/li&gt;
  &lt;li&gt;切回session1线程，执行row_insert_for_mysql，观察返回值err发现是DB_DUPLICATE_KEY，证明了上面的猜测。&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&quot;解决方案&quot;&gt;解决方案&lt;/h2&gt;
和业务沟通发现以后，发现业务的数据有2部分来源
&lt;ol&gt;
  &lt;li&gt;历史库老数据，对于这部分数据，insert的时候带id，同时希望插入到新库里面保持id不变&lt;/li&gt;
  &lt;li&gt;线上生产的新数据，这部分数据，insert不带id，使用系统分配自增值&lt;/li&gt;
&lt;/ol&gt;

针对这种问题，只需要保证这两部分数据id不冲突就好了，那么可以先查一下历史库最大的id值多少，然后调用alter命令修改表的auto inc值，保证比历史库最大的值还要大1，就可以避免冲突。

</description>
        <pubDate>Sun, 15 Sep 2024 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2024/09/15/mysql-autoinc-problem/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2024/09/15/mysql-autoinc-problem/</guid>
        
        
        <category>innodb</category>
        
      </item>
    
      <item>
        <title>基于redo log的强一致mysql集群--DDL</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#实现&quot; id=&quot;markdown-toc-实现&quot;&gt;实现&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#create-table&quot; id=&quot;markdown-toc-create-table&quot;&gt;create table&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#drop-table&quot; id=&quot;markdown-toc-drop-table&quot;&gt;drop table&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#rename-table&quot; id=&quot;markdown-toc-rename-table&quot;&gt;rename table&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
今天篇文章介绍一下为了支持强一致，DDL相关的改动。临时表不用做到强一致同步给follower节点，所以下面说的都是普通的用户表。我们之前的文章也介绍了raft模块嵌入到innodb存储引擎中，所以我们只支持innodb表强一致。&lt;br /&gt;
先介绍一下crash recover流程里面关于ibd文件的操作：&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;1. fil_scan_for_tablespaces扫描磁盘上的ibd文件，获取space_id和name信息&amp;lt;br/&amp;gt;
2. apply redo log，文件操作的redo log是在文件操作之后才写的，看到这类log说明文件操作已经成功，对于这类redo log，只是检查一下文件状态&amp;lt;br/&amp;gt;
3. Validate_files::validate检查mysql.tablespaces表里面的信息和ibd文件信息是否一致，包括文件名字，同时如果不是shutdown的话，还会检查space_id等信息&amp;lt;br/&amp;gt;
4. log_ddl-&amp;gt;recover会扫描DDL_Log_Table表，回放文件操作&amp;lt;br/&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;h2 id=&quot;实现&quot;&gt;实现&lt;/h2&gt;
&lt;h4 id=&quot;create-table&quot;&gt;create table&lt;/h4&gt;
create table流程&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;1. 检查ibd文件是否存在，存在就直接返回失败&amp;lt;br/&amp;gt;
2. dd::create_table 创建内存dd::table对象，然后store, 要等整个DDL事务commit生效&amp;lt;br/&amp;gt;
3. innodb::create&amp;lt;br/&amp;gt;
3.1 分配table_id和space_id&amp;lt;br/&amp;gt;
3.2 写ddl_log，写入的操作都是刚好和create table相反的操作，用于回滚DDL操作&amp;lt;br/&amp;gt;
3.3 创建ibd文件&amp;lt;br/&amp;gt;
3.4 写redo log MLOG_FILE_CREATE&amp;lt;br/&amp;gt;
4 trx commit/rollback  DD数据生效，ddl_log删除&amp;lt;br/&amp;gt;
5 post_ddl commit操作啥都不干，rollback就回放DDL log&amp;lt;br/&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
针对DDL操作的修改点：
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;1. 为了支持follower节点执行文件操作，MLOG_FILE_CREATE等类型的redo log需要在follower节点执行对应的文件操作&amp;lt;br/&amp;gt;
2. log_ddl-&amp;gt;recover只能在leader节点执行，follower节点跳过，leader节点执行recover以后会把redo log发给follower节点，follower节点apply redo log保证和leader节点状态一致&amp;lt;br/&amp;gt;
3. 如果创建了ibd文件，leader节点现在比follower节点多了一个ibd文件，再还没有写入MLOG_FILE_CREATE类型的log之前leader节点出现了crash，leader节点变成follower节点, follower节点成为新的leader节点以后会执行log_ddl-&amp;gt;recover，调用replay_delete_space_log函数删除ibd文件，那么需要写入redo log(MLOG_FILE_DELETE)告诉原来的leader节点(现在的follower节点删除ibd文件), 新的follower节点apply这条redo log的时候需要去删除ibd文件。&amp;lt;br/&amp;gt;
4. leader节点创建完ibd文件，写完MLOG_FILE_CREATE redo log以后出现crash，leader节点变成follower节点以后重新apply这条日志的时候会发现ibd文件已经存在，需要兼容这种情况。&amp;lt;br/&amp;gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;h4 id=&quot;drop-table&quot;&gt;drop table&lt;/h4&gt;
drop table流程&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;1. 前置检查
2. table cache里面删除table
3. DDL_Log_Table表先插入drop log，后插入delete space log, 要等整个DDL事务commit生效
4. 删除dd::tablespace信息
5. 删除dd::table信息
6. trx commit/rollback
7. post_ddl 事务commit后，DDL_Log_Table表记录可见，搜索出来，写入MLOG_FILE_DELETE，然后删除ibd文件
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
和create table最大的不同是DDL_Log_Table表插入不是相反操作，事务commit以后才会删除ibd文件&lt;br /&gt;
如果trx commit之前，leader出现crash，因为文件还没有操作，所以回归事务就可以了。如果trx commit成功以后出现crash，
那么log_ddl-&amp;gt;recover会扫描DDL_Log_Table表，回放文件操作&lt;br /&gt;
&lt;h4 id=&quot;rename-table&quot;&gt;rename table&lt;/h4&gt;
rename table流程&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;1. 前置检查
2. DDL_Log_Table表插入rename space log(马上生效)，同时delete record(整个DDL事务commit生效)
3. 写MLOG_FILE_RENAME redo log
4. rename ibd文件
5. DDL_Log_Table表插入rename table log(马上生效)，同时delete record(整个DDL事务commit生效)
6. 更新dd::tablespace信息
7. 更新dd::table信息
8. trx commit/rollback
9. post_ddl commit操作啥都不干，rollback就回放DDL log
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
假设各种crash场景:&lt;br /&gt;
&lt;ol&gt;
  &lt;li&gt;如果步骤2执行结束出现crash,新leader调用log_ddl-&amp;gt;recover会扫描DDL_Log_Table表，发现ibd文件名字没有修改会直接返回&lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;如果步骤3执行结束出现crash, 在前面create table里面我们说过，为了支持follower节点操作ibd文件，follower apply MLOG_FILE_RENAME redo log的时候，需要去rename ibd文件&lt;br /&gt;
和前面场景1一样，log_ddl-&amp;gt;recover会扫描DDL_Log_Table表,会重新rename回去&lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;如果步骤4执行结束出现crash, 和步骤3一样，log_ddl-&amp;gt;recover会扫描DDL_Log_Table表，回放文件操作&lt;br /&gt;&lt;/li&gt;
&lt;/ol&gt;

</description>
        <pubDate>Sat, 15 Jun 2024 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2024/06/15/mysql-raft_3/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2024/06/15/mysql-raft_3/</guid>
        
        
        <category>raft</category>
        
      </item>
    
      <item>
        <title>基于redo log的强一致mysql集群--写入篇</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#实现&quot; id=&quot;markdown-toc-实现&quot;&gt;实现&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
上一篇文章介绍一下整体架构，这篇文章详细介绍一下写入流程。&lt;br /&gt;
raft通信协议里面使用term和index来标识一条日志(我们用entry来表示)。
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;type Entry struct {
	Term  uint64    `protobuf:&quot;varint,2,opt,name=Term&quot; json:&quot;Term&quot;`
	Index uint64    `protobuf:&quot;varint,3,opt,name=Index&quot; json:&quot;Index&quot;`
	Type  EntryType `protobuf:&quot;varint,1,opt,name=Type,enum=raftpb.EntryType&quot; json:&quot;Type&quot;`
	Data  []byte    `protobuf:&quot;bytes,4,opt,name=Data&quot; json:&quot;Data,omitempty&quot;`
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
这个是etcd里面的entry结构体定义。&lt;br /&gt;
因为我们是直接传输innodb的redo log，这样就涉及到一个转化问题，怎么用term和index来表示一段redo log. &lt;br /&gt;

&lt;h2 id=&quot;实现&quot;&gt;实现&lt;/h2&gt;
一个很自然的想法就是把一段redo log的内容放到entry data部分。innodb里面的mtr会写入一个完整的redo record，
那么我们可以简单的把一个完整的redo record当作一个entry。&lt;br /&gt;
了解innodb redo log的同学应该知道，redo record第一个字段表示类型，我们可以在这个字段后面添加term, index字段，这样就表示出来一个redo record对应一个entry。&lt;br /&gt;
但是这么做最大的问题就是和官方的redo log格式不兼容了。后续内核升级的话，有新的redo record type类型都做要开发适配工作。&lt;br /&gt;
同时这么也会导致redo log写放大问题比较严重。&lt;br /&gt;
我们选择的方案是新增一个redo record type表示raft entry的meta信息(term, index，对应的data从那个lsn开始，data size)。这种方案代码修改量比较少，新增一个redo record type写入函数和解析函数就可以了，还可以控制entry的大小，多个redo record合并成一个entry，减少写放大问题&lt;br /&gt;
这个方案还要解决一个问题如何根据index快速在redo log文件里面寻找对应的redo log内容。&lt;br /&gt;
首先我们可以内存cache一下index和lsn的映射，如果内存cache里面没有，那么需要读redo log文件。我们还可以cache一下redo log最大和最小entry，这样可以先2分查找先定位在哪个文件，然后在某个文件里面搜索entry meta信息。&lt;br /&gt;
这个方案的架构图如下：&lt;br /&gt;
&lt;img src=&quot;/images/raft_2.jpg&quot; alt=&quot;avatar&quot; /&gt;
可以看到在mtr commit向log.buf拷贝数据的时候，会额外写raft meta data到log.buf里面，log_writer线程除了本身自己的工作外&lt;br /&gt;
还需要把log.buf里面的数据copy到raft entry cache中，唤醒raft线程拷贝日志数据给follower节点.&lt;br /&gt;
follower节点对用户是禁写的，只允许raft模块接收数据，然后把数据copy到log.buf，再通过log_writer线程刷盘。只有数据刷盘以后，follower节点才会给leader节点回包。&lt;br /&gt;
leader节点收到follower节点回包后，会根据Quorum机制，更新commitIndex。&lt;br /&gt;
另外还有一个后台线程根据commitIndex，更新多数派的lsn。用户线程在trx commit的时候会等待lsn推进到多数派lsn，这样可以保证日志达成多数派以后才给用户返回结果。&lt;br /&gt;
还有一个问题要处理，follower节点日志落后很多的时候，cache中不存在要发送的数据，需要从redo log文件中读数据，如果这个时候leader节点写流量比较大，很容易会导致follower节点一直追不上leader节点，为此我们设计了后台的预读线程，负责批量读将要发送给follower节点的数据。&lt;br /&gt;
大家也都知道mysql里面checkpoint_lsn之前的redo log可以安全删除，不会造成数据丢失。&lt;br /&gt;
在我们这个场景里面还需要加一个限制，要删除的数据必须都已经同步到所有的follower节点了，否则会导致follower节点来获取数据，发现数据已经被删除了。&lt;br /&gt;
</description>
        <pubDate>Thu, 16 May 2024 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2024/05/16/mysql-raft_2/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2024/05/16/mysql-raft_2/</guid>
        
        
        <category>raft</category>
        
      </item>
    
      <item>
        <title>基于redo log的强一致mysql集群--整体架构篇</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#整体架构&quot; id=&quot;markdown-toc-整体架构&quot;&gt;整体架构&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#启动流程&quot; id=&quot;markdown-toc-启动流程&quot;&gt;启动流程&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#checkpoint&quot; id=&quot;markdown-toc-checkpoint&quot;&gt;checkpoint&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#buf-pool&quot; id=&quot;markdown-toc-buf-pool&quot;&gt;buf pool&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#事务&quot; id=&quot;markdown-toc-事务&quot;&gt;事务&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#写流程&quot; id=&quot;markdown-toc-写流程&quot;&gt;写流程&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#follower节点&quot; id=&quot;markdown-toc-follower节点&quot;&gt;follower节点&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
基于传统的异步复制或者半同步复制，不能保证主从节点的数据一致性。所以我们在mysql8.0集群做了一些强一致方面的工作: 基于raft分布式一致性协议进行物理日志redo log复制的强一致数据库。&lt;br /&gt;
部署形态方面: 一个集群一般部署三个节点，分布在同一个城市的三个机房，达到机房容灾。一致性协议会协商产生一个Leader节点，其它节点作为Follower节点。Leader节点作为整个集群唯一的可写节点，提供读写功能，同时基于成本的考虑，第三个节点选择只存储log日志，不存储数据，称之为log节点(同样可以参与投票选主，只不过是当选leader以后会主动发起切主，让出leader角色)。&lt;br /&gt;
mysql官方其实也有强一致的方案: MySQL GroupReplication。但是mgr模式有下面一些缺点让我们放弃使用，选择自研。&lt;br /&gt;
第一: mgr模式必须要开启binlog，对于有的业务来说binlog不需要必须的，开启了binlog性能肯定会出现下降。&lt;br /&gt;
第二: 对于大事务，mgr性能很差，甚至会直接报错。&lt;br /&gt;
第三: mgr目前还存在不少bug，不够成熟。&lt;br /&gt;
下面看一个简单的case比较: 在同样的环境部署3个实例，使用sysbench write_only模式创建一张表，插入500万行数据。&lt;br /&gt;
mgr测试结果如下:&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;mysql&amp;gt; update sbtest1 set k = k + 1 where id &amp;gt; 4600000;
ERROR 3100 (HY000): Error on observer while running replication hook &apos;before_commit&apos;.
mysql&amp;gt; update sbtest1 set k = k + 1 where id &amp;gt; 4650000;
Query OK, 350000 rows affected (9.93 sec)
Rows matched: 350000  Changed: 350000  Warnings: 0
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
可以看到一次更新行数比较多的时候，mgr会直接报错，不会执行成功。对于更新35万行数据，总共花费了9秒9。&lt;br /&gt;
再看一下我们自研的强一致数据库的性能: &lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;开启binlog
mysql&amp;gt; update sbtest1 set k = k + 1 where id &amp;gt; 4650000;
Query OK, 350000 rows affected (5.48 sec)
Rows matched: 350000  Changed: 350000  Warnings: 0
关闭binlog
mysql&amp;gt; update sbtest1 set k = k + 1 where id &amp;gt; 4650000;
Query OK, 350000 rows affected (3.54 sec)
Rows matched: 350000  Changed: 350000  Warnings: 0
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
可以看到开启binlog模式只需要5秒5的时间，关闭binlog只要3秒5，性能方面完全碾压mgr。&lt;br /&gt;

&lt;h2 id=&quot;整体架构&quot;&gt;整体架构&lt;/h2&gt;
&lt;img src=&quot;/images/raft_1.jpg&quot; alt=&quot;avatar&quot; /&gt;
可以看到我们把raft模块嵌入到innodb层里面了，不同与目前开源的一些产品，raft模块单独维护一份日志，我们直接通过复制innodb存储引擎的redo log保证mysql集群之间数据一致，与mgr采用binlog同步对比，我们的性能更好。因为binlog同步是在事务commit的触发，而我们的redo log(mtr产生，一个事务会有很多小的mtr)可以很早同步到follower节点，同时又可以避免大事务问题。当然这样做的缺点是代码入侵很大，和官方代码差异很大。&lt;br /&gt;
下面分模块大致介绍一下，做了那些修改。&lt;br /&gt;

&lt;h3 id=&quot;启动流程&quot;&gt;启动流程&lt;/h3&gt;
不管mysql是否正常shutdown，我们都选择走crash recover流程，同时我们使用raft里面的follower角色启动mysql(在没有选主之前，mysql是只读模式)。&lt;br /&gt;
为了保证redo log强一致，redo log回放机制和原来很不一样，首先我们做一次扫描操作，找到最后的redo log信息，然后作为follower参与raft选主的日志信息(raft选主需要和其他节点比较日志)。选主以后，follower节点需要truncate掉自己的redo log里面不一致的数据。然后通过raft模块从leader节点接收redo log，对齐日志。做完这些以后，才真正开始做crash recover流程，apply redo log对齐数据内容。&lt;br /&gt;

&lt;h3 id=&quot;checkpoint&quot;&gt;checkpoint&lt;/h3&gt;
mysql打完checkpoint以后可以安全删除之前的redo log，所以我们需要保证被删除的redo log肯定是一致的。因此在打checkpoint的时候会限制checkpoit_lsn不能大于集群达成多数派的lsn。&lt;br /&gt;

&lt;h3 id=&quot;buf-pool&quot;&gt;buf pool&lt;/h3&gt;
buffer pool刷脏的时候同样也需要受到raft模块约束，要保证脏页的lsn不大于集群达成多数派的lsn，否则磁盘就有脏数据。&lt;br /&gt;

&lt;h3 id=&quot;事务&quot;&gt;事务&lt;/h3&gt;
事务commit的时候需要保证日志达成多数派以后才会给客户端返回，否则就是事务提交失败。&lt;br /&gt;

&lt;h3 id=&quot;写流程&quot;&gt;写流程&lt;/h3&gt;
&lt;img src=&quot;/images/raft_3.jpg&quot; alt=&quot;avatar&quot; /&gt;
可以看到事务执行过程中每次mtr生成日志，写入到log.buf以后，我们会并发的写磁盘redo log文件和传输日志到follower节点，写入follower节点的redo log文件，等多数派日志都落盘以后，事务就可以安全提交了。&lt;br /&gt;
后面的文章再详细介绍各个模块的具体修改。&lt;br /&gt;

&lt;h3 id=&quot;follower节点&quot;&gt;follower节点&lt;/h3&gt;
follower节点收到redo log以后会类似crash recover那样去apply redo log，同时我们需要限制follower节点只能apply 达成多数派的redo log。

</description>
        <pubDate>Thu, 16 May 2024 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2024/05/16/mysql-raft/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2024/05/16/mysql-raft/</guid>
        
        
        <category>raft</category>
        
      </item>
    
      <item>
        <title>mysql 读写锁解析</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#结构体&quot; id=&quot;markdown-toc-结构体&quot;&gt;结构体&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#读锁&quot; id=&quot;markdown-toc-读锁&quot;&gt;读锁&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#写锁&quot; id=&quot;markdown-toc-写锁&quot;&gt;写锁&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#sx锁&quot; id=&quot;markdown-toc-sx锁&quot;&gt;sx锁&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#参考资料&quot; id=&quot;markdown-toc-参考资料&quot;&gt;参考资料&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
mysql有很多锁，今天看下读写锁是怎么实现的，5.7版本新增了sx锁，先从简单的没有sx锁的版本。&lt;br /&gt;

&lt;h2 id=&quot;结构体&quot;&gt;结构体&lt;/h2&gt;
先来看下结构体，下面是精简版&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;struct rw_lock_t
{
	volatile lint	lock_word;  //计数器
	volatile ulint	waiters; // = 1表示有线程在等锁，可能等写锁，可能等读锁
	volatile bool	recursive; // 是否递归锁
	volatile os_thread_id_t	writer_thread; // 持有写锁的线程id
	os_event_t	event;  // 等待信号量
	os_event_t	wait_ex_event; // 扩展等待信号量，写锁排队的时候使用
	/** The mutex protecting rw_lock_t */
	mutable ib_mutex_t mutex; //锁保护，可以用原子操作代替
};
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
lock_word初始化是X_LOCK_DECR，每次读锁的时候，lock_word就减1，每次写锁的时候，lock_word就减X_LOCK_DECR。&lt;br /&gt;
下面是lock_word取值范围的说明：&lt;br /&gt;
lock_word == X_LOCK_DECR:      Unlocked. &lt;br /&gt;

0 &amp;lt; lock_word &amp;lt; X_LOCK_DECR: &lt;br /&gt; 
Read locked, no waiting writers. (X_LOCK_DECR - lock_word) is the number of readers that hold the lock. &lt;br /&gt;

lock_word == 0:		       Write locked &lt;br /&gt;

-X_LOCK_DECR &amp;lt; lock_word &amp;lt; 0: &lt;br /&gt; 
Read locked, with a waiting writer. (-lock_word) is the number of readers that hold the lock. &lt;br /&gt;

lock_word &amp;lt;= -X_LOCK_DECR: &lt;br /&gt;
Recursively write locked. lock_word has been decremented by X_LOCK_DECR once for each lock, so the number of locks is: ((-lock_word) / X_LOCK_DECR) + 1 &lt;br /&gt;

When lock_word &amp;lt;= -X_LOCK_DECR, we also know that lock_word % X_LOCK_DECR == 0: other values of lock_word are invalid. &lt;br /&gt;

&lt;img src=&quot;/images/rw_lock.jpg&quot; alt=&quot;avatar&quot; /&gt;

&lt;h2 id=&quot;读锁&quot;&gt;读锁&lt;/h2&gt;
mysql里面的s锁就是读锁, 读锁调用的都是rw_lock_s_lock_func函数，下面是函数精简实现。
先调用rw_lock_s_lock_low函数，如果lock_word &amp;gt; 0, 就减1, 加锁成功。&lt;br /&gt;
否则就调用rw_lock_s_lock_spin函数等待(这样可以保证写锁不会饿死)。先判断lock_word是否 &amp;lt;= 0, 如果是的话，就先让出cpu &lt;br /&gt;
再次尝试调用rw_lock_s_lock_low，加锁成功返回，否则就申请cell, wait等待在lock-&amp;gt;event。&lt;br /&gt;
如果被唤醒再次循环刚才的流程 &lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;bool
rw_lock_lock_word_decr(
/*===================*/
	rw_lock_t*	lock,		/*!&amp;lt; in/out: rw-lock */
	ulint		amount,		/*!&amp;lt; in: amount to decrement */
	lint		threshold)	/*!&amp;lt; in: threshold of judgement */
{
	bool success = false;
	mutex_enter(&amp;amp;(lock-&amp;gt;mutex));
	if (lock-&amp;gt;lock_word &amp;gt; threshold) {
		lock-&amp;gt;lock_word -= amount;
		success = true;
	}
	mutex_exit(&amp;amp;(lock-&amp;gt;mutex));
	return(success);
}
@return TRUE if success */
bool rw_lock_s_lock_low(rw_lock_t*	lock)
{
	if (!rw_lock_lock_word_decr(lock, 1, 0)) {
		/* Locking did not succeed */
		return(false);
	}

	return(true);	/* locking succeeded */
}
void rw_lock_s_lock_func(
	rw_lock_t*	lock,	/*!&amp;lt; in: pointer to rw-lock */
	ulint		pass,	/*!&amp;lt; in: pass value; != 0, if the lock will
				be passed to another thread to unlock */
	const char*	file_name,/*!&amp;lt; in: file name where lock requested */
	ulint		line)	/*!&amp;lt; in: line where requested */
{
	if (!rw_lock_s_lock_low(lock, pass, file_name, line)) {
		/* Did not succeed, try spin wait */
		rw_lock_s_lock_spin(lock, pass, file_name, line);
	}
}

void rw_lock_s_lock_spin(
	rw_lock_t*	lock,	/*!&amp;lt; in: pointer to rw-lock */
	ulint		pass,	/*!&amp;lt; in: pass value; != 0, if the lock
				will be passed to another thread to unlock */
	const char*	file_name, /*!&amp;lt; in: file name where lock requested */
	ulint		line)	/*!&amp;lt; in: line where requested */
{
	ulint		i = 0;	/* spin round count */
	sync_array_t*	sync_arr;
	ulint		spin_count = 0;
	uint64_t	count_os_wait = 0;

lock_loop:

	/* Spin waiting for the writer field to become free */
	os_rmb;
	while (i &amp;lt; srv_n_spin_wait_rounds &amp;amp;&amp;amp; lock-&amp;gt;lock_word &amp;lt;= 0) {
		if (srv_spin_wait_delay) {
			ut_delay(ut_rnd_interval(0, srv_spin_wait_delay));
		}

		i++;
	}

	if (i &amp;gt;= srv_n_spin_wait_rounds) {
		os_thread_yield();
	}

	++spin_count;

	/* We try once again to obtain the lock */
	if (rw_lock_s_lock_low(lock, pass, file_name, line)) {
		return; /* Success */
	} else {

		if (i &amp;lt; srv_n_spin_wait_rounds) {
			goto lock_loop;
		}


		++count_os_wait;

		sync_cell_t*	cell;

		sync_arr = sync_array_get_and_reserve_cell(
				lock, RW_LOCK_S, file_name, line, &amp;amp;cell);

		/* Set waiters before checking lock_word to ensure wake-up
		signal is sent. This may lead to some unnecessary signals. */
		rw_lock_set_waiter_flag(lock);

		if (rw_lock_s_lock_low(lock, pass, file_name, line)) {

			sync_array_free_cell(sync_arr, cell);
			return; /* Success */
		}

		sync_array_wait_event(sync_arr, cell);

		i = 0;

		goto lock_loop;
	}
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
在来看下解锁读锁，比较简单，就是对lock_word+1，如果lock_word== 0说明已经没有其他线程持有读锁，
并且有写锁等待就唤醒写锁 &lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;void rw_lock_s_unlock_func(
	rw_lock_t*	lock)	/*!&amp;lt; in/out: rw-lock */
{

	/* Increment lock_word to indicate 1 less reader */
	lint	lock_word = rw_lock_lock_word_incr(lock, 1);
	if (lock_word == 0) {

		/* wait_ex waiter exists. It may not be asleep, but we signal
		anyway. We do not wake other waiters, because they can&apos;t
		exist without wait_ex waiter and wait_ex waiter goes first.*/
		os_event_set(lock-&amp;gt;wait_ex_event);

	}
}
lint rw_lock_lock_word_incr(
	rw_lock_t*	lock,		/*!&amp;lt; in/out: rw-lock */
	ulint		amount)		/*!&amp;lt; in: amount of increment */
{
	lint local_lock_word;

	mutex_enter(&amp;amp;(lock-&amp;gt;mutex));

	lock-&amp;gt;lock_word += amount;
	local_lock_word = lock-&amp;gt;lock_word;

	mutex_exit(&amp;amp;(lock-&amp;gt;mutex));

	return(local_lock_word);
}

&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;写锁&quot;&gt;写锁&lt;/h2&gt;
mysql里面的x锁就是写锁，底层调用的是rw_lock_x_lock_func函数。 &lt;br /&gt;
先调用rw_lock_x_lock_low函数，加锁成功就返回true，否则返回false。 &lt;br /&gt;
加锁失败的话，就申请一个cell，然后等待lock-&amp;gt;event通知。&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;void rw_lock_x_lock_func(
	rw_lock_t*	lock,	/*!&amp;lt; in: pointer to rw-lock */
	ulint		pass,	/*!&amp;lt; in: pass value; != 0, if the lock will
				be passed to another thread to unlock */
	const char*	file_name,/*!&amp;lt; in: file name where lock requested */
	ulint		line)	/*!&amp;lt; in: line where requested */
{
	ulint		i = 0;
	sync_array_t*	sync_arr;
	ulint		spin_count = 0;
	uint64_t	count_os_wait = 0;

lock_loop:

	if (rw_lock_x_lock_low(lock, pass, file_name, line)) {
		/* Locking succeeded */
		return;

	} else {
		/* Spin waiting for the lock_word to become free */
		os_rmb;
		while (i &amp;lt; srv_n_spin_wait_rounds
		       &amp;amp;&amp;amp; lock-&amp;gt;lock_word &amp;lt;= 0) {

			if (srv_spin_wait_delay) {
				ut_delay(ut_rnd_interval(
						0, srv_spin_wait_delay));
			}

			i++;
		}

		spin_count += i;

		if (i &amp;gt;= srv_n_spin_wait_rounds) {

			os_thread_yield();

		} else {

			goto lock_loop;
		}
	}

	sync_cell_t*	cell;

	sync_arr = sync_array_get_and_reserve_cell(
			lock, RW_LOCK_X, file_name, line, &amp;amp;cell);

	/* Waiters must be set before checking lock_word, to ensure signal
	is sent. This could lead to a few unnecessary wake-up signals. */
	rw_lock_set_waiter_flag(lock);

	if (rw_lock_x_lock_low(lock, pass, file_name, line)) {
		sync_array_free_cell(sync_arr, cell);
		/* Locking succeeded */
		return;
	}

	sync_array_wait_event(sync_arr, cell);

	i = 0;

	goto lock_loop;
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
先看下rw_lock_x_lock_wait_func函数的实现。&lt;br /&gt;
如果lock_word &amp;gt;= threshold，直接return。&lt;br /&gt;
否则就申请cell，等待lock-&amp;gt;wait_ex_event。 &lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;void
rw_lock_x_lock_wait_func(
/*=====================*/
	rw_lock_t*	lock,	/*!&amp;lt; in: pointer to rw-lock */
	lint		threshold,/*!&amp;lt; in: threshold to wait for */
	const char*	file_name,/*!&amp;lt; in: file name where lock requested */
	ulint		line)	/*!&amp;lt; in: line where requested */
{
	ulint		i = 0;
	ulint		n_spins = 0;
	sync_array_t*	sync_arr;
	uint64_t	count_os_wait = 0;

	os_rmb;

	while (lock-&amp;gt;lock_word &amp;lt; threshold) {

		if (srv_spin_wait_delay) {
			ut_delay(ut_rnd_interval(0, srv_spin_wait_delay));
		}

		if (i &amp;lt; srv_n_spin_wait_rounds) {
			i++;
			os_rmb;
			continue;
		}

		/* If there is still a reader, then go to sleep.*/
		++n_spins;

		sync_cell_t*	cell;

		sync_arr = sync_array_get_and_reserve_cell(
			lock, RW_LOCK_X_WAIT, file_name, line, &amp;amp;cell);

		i = 0;

		/* Check lock_word to ensure wake-up isn&apos;t missed.*/
		if (lock-&amp;gt;lock_word &amp;lt; threshold) {
			sync_array_wait_event(sync_arr, cell);

			/* It is possible to wake when lock_word &amp;lt; 0.
			We must pass the while-loop check to proceed.*/

		} else {
			sync_array_free_cell(sync_arr, cell);
			break;
		}
	}
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
下面看具体的rw_lock_x_lock_low的实现。&lt;br /&gt;
首先比较lock_word，如果lock_word &amp;gt; 0，就减去X_LOCK_DECR，然后调用rw_lock_x_lock_wait_func函数，等待lock_word &amp;gt;= 0。条件满足，等待结束就表示加锁成功了。这种情况属于加写锁之前都是读锁，没有写锁&lt;br /&gt;
如果lock_word &amp;lt;= 0，说明之前已经有其他线程抢到写锁了。&lt;br /&gt;
如果之前加锁的线程不是本线程，那么加写锁失败，return false。&lt;br /&gt;
否则就是同一个线程再次加写锁，并且是递归锁的话，就减去X_LOCK_DECR。&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;bool rw_lock_x_lock_low(
/*===============*/
	rw_lock_t*	lock,	/*!&amp;lt; in: pointer to rw-lock */
	ulint		pass,	/*!&amp;lt; in: pass value; != 0, if the lock will
				be passed to another thread to unlock */
	const char*	file_name,/*!&amp;lt; in: file name where lock requested */
	ulint		line)	/*!&amp;lt; in: line where requested */
{
	if (rw_lock_lock_word_decr(lock, X_LOCK_DECR, 0)) {
		/* Decrement occurred: we are writer or next-writer. */
		rw_lock_set_writer_id_and_recursion_flag(lock, !pass);

		rw_lock_x_lock_wait(lock, pass, 0, file_name, line);

	} else {
		os_thread_id_t	thread_id = os_thread_get_curr_id();
                /* Decrement failed: relock or failed lock */
		if (!pass &amp;amp;&amp;amp; lock-&amp;gt;recursive
		    &amp;amp;&amp;amp; os_thread_eq(lock-&amp;gt;writer_thread, thread_id)) {
			/* Relock */
                        lock-&amp;gt;lock_word -= X_LOCK_DECR;
		} else {
			/* Another thread locked before us */
			return(false);
		}
	}

	return(true);
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
下面再来看下写锁的解锁实现。&lt;br /&gt;
首先判断如果lock_word == 0说明是第一次加的写锁，那么lock_word + X_LOCK_DECR，然后判断是否有waiters(可能是读锁或者写锁等待)，如果有的话就通知一下其他waiters。&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;void rw_lock_x_unlock_func(
	rw_lock_t*	lock)	/*!&amp;lt; in/out: rw-lock */
{
	if (lock-&amp;gt;lock_word == 0) {
		/* Last caller in a possible recursive chain. */
		lock-&amp;gt;recursive = FALSE;
	}

	if (rw_lock_lock_word_incr(lock, X_LOCK_DECR) == X_LOCK_DECR) {
		/* There is 1 x-lock */
		/* atomic increment is needed, because it is last */

		if (lock-&amp;gt;waiters) {
			rw_lock_reset_waiter_flag(lock);
			os_event_set(lock-&amp;gt;event);
		}
        }
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;sx锁&quot;&gt;sx锁&lt;/h2&gt;
mysql新加的共享排它锁，先来看下相容性矩阵。&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;  | S|SX| X|
--+--+--+--+
S | o| o| x|
--+--+--+--+
SX| o| x| x|
--+--+--+--+
X | x| x| x|
--+--+--+--+
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
S锁和X锁与之前的逻辑相同，没有做变动，SX与SX和X互斥，与S共享，在加上SX锁之后，不会影响读操作，但阻塞写操作。 &lt;br /&gt;
背景参考 &lt;a href=&quot;http://mysql.taobao.org/monthly/2015/07/05/&quot;&gt;内核文章&lt;/a&gt; &lt;br /&gt;
lock_word新取值范围的说明：&lt;br /&gt;
lock_word == X_LOCK_DECR:	Unlocked. &lt;br /&gt;

X_LOCK_HALF_DECR &amp;lt; lock_word &amp;lt; X_LOCK_DECR: &lt;br /&gt;
S locked, no waiting writers.(X_LOCK_DECR - lock_word) is the number of S locks. &lt;br /&gt;

lock_word == X_LOCK_HALF_DECR:	SX locked, no waiting writers. &lt;br /&gt;
0 &amp;lt; lock_word &amp;lt; X_LOCK_HALF_DECR: &lt;br /&gt;

SX locked AND S locked, no waiting writers.(X_LOCK_HALF_DECR - lock_word) is the number of S locks. &lt;br /&gt;

lock_word == 0:			X locked, no waiting writers. &lt;br /&gt;

-X_LOCK_HALF_DECR &amp;lt; lock_word &amp;lt; 0: &lt;br /&gt;
S locked, with a waiting writer.(-lock_word) is the number of S locks. &lt;br /&gt;

lock_word == -X_LOCK_HALF_DECR:	X locked and SX locked, no waiting writers. &lt;br /&gt;

-X_LOCK_DECR &amp;lt; lock_word &amp;lt; -X_LOCK_HALF_DECR: &lt;br /&gt;
S locked, with a waiting writer which has SX lock. -(lock_word + X_LOCK_HALF_DECR) is the number of S locks. &lt;br /&gt;

lock_word == -X_LOCK_DECR:	X locked with recursive X lock (2 X locks). &lt;br /&gt;

-(X_LOCK_DECR + X_LOCK_HALF_DECR) &amp;lt; lock_word &amp;lt; -X_LOCK_DECR: &lt;br /&gt;
X locked. The number of the X locks is: 2 - (lock_word + X_LOCK_DECR) &lt;br /&gt;

lock_word == -(X_LOCK_DECR + X_LOCK_HALF_DECR): &lt;br /&gt;
X locked with recursive X lock (2 X locks) and SX locked. &lt;br /&gt;

lock_word &amp;lt; -(X_LOCK_DECR + X_LOCK_HALF_DECR): &lt;br /&gt;
X locked and SX locked.The number of the X locks is:2 - (lock_word + X_LOCK_DECR + X_LOCK_HALF_DECR) &lt;br /&gt;

####读锁
读锁的逻辑和原来没有变化，当lock_word &amp;gt; 0的时候可以加读写，成功以后lock_work - 1. &lt;br /&gt;
解锁的时候lock_work + 1, 多了一个变化是如果lock_work == -X_LOCK_HALF_DECR 唤醒wait_ex_event. &lt;br /&gt;

####写锁
加锁失败的时候，需要等待lock_word &amp;gt; X_LOCK_HALF_DECR. SX锁和X锁互斥。 &lt;br /&gt;
rw_lock_x_lock_low判断lock_word &amp;gt; X_LOCK_HALF_DECR，才会等待lock_word &amp;gt; 0，表示加锁成功。&lt;br /&gt;

####SX加锁
加锁逻辑和X锁差不多，如果rw_lock_sx_lock_low加锁成功直接返回，否则就等待lock-&amp;gt;event直到lock_word &amp;gt; X_LOCK_HALF_DECR. &lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;void rw_lock_sx_lock_func(
    rw_lock_t *lock,       /*!&amp;lt; in: pointer to rw-lock */
    ulint pass,            /*!&amp;lt; in: pass value; != 0, if the lock will
                           be passed to another thread to unlock */
    const char *file_name, /*!&amp;lt; in: file name where lock requested */
    ulint line)            /*!&amp;lt; in: line where requested */

{
  ulint i = 0;
  sync_array_t *sync_arr;


lock_loop:

  if (rw_lock_sx_lock_low(lock, pass, file_name, line)) {
    /* Locking succeeded */
    return;

  } else {

    /* Spin waiting for the lock_word to become free */
    os_rmb;
    while (i &amp;lt; srv_n_spin_wait_rounds &amp;amp;&amp;amp; lock-&amp;gt;lock_word &amp;lt;= X_LOCK_HALF_DECR) {
      if (srv_spin_wait_delay) {
        ut_delay(ut_rnd_interval(0, srv_spin_wait_delay));
      }

      i++;
    }

    if (i &amp;gt;= srv_n_spin_wait_rounds) {
      std::this_thread::yield();

    } else {
      goto lock_loop;
    }
  }

  sync_cell_t *cell;

  sync_arr =
      sync_array_get_and_reserve_cell(lock, RW_LOCK_SX, file_name, line, &amp;amp;cell);

  /* Waiters must be set before checking lock_word, to ensure signal
  is sent. This could lead to a few unnecessary wake-up signals. */
  rw_lock_set_waiter_flag(lock);

  if (rw_lock_sx_lock_low(lock, pass, file_name, line)) {
    sync_array_free_cell(sync_arr, cell);

    /* Locking succeeded */
    return;
  }

  ++count_os_wait;

  sync_array_wait_event(sync_arr, cell);

  i = 0;

  goto lock_loop;
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
rw_lock_sx_lock_low 先判断lock_word &amp;gt; X_LOCK_HALF_DECR, 如果成立就减去X_LOCK_HALF_DECR。&lt;br /&gt;
否则就判断之前加锁的线程是不是本线程，如果不是说明有其他线程加锁sx锁或者x锁，返回false,如果是就减去X_LOCK_HALF_DECR, 加锁成功。&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;bool rw_lock_sx_lock_low(
    rw_lock_t *lock,       /*!&amp;lt; in: pointer to rw-lock */
    ulint pass,            /*!&amp;lt; in: pass value; != 0, if the lock will
                           be passed to another thread to unlock */
    const char *file_name, /*!&amp;lt; in: file name where lock requested */
    ulint line)            /*!&amp;lt; in: line where requested */
{
  if (rw_lock_lock_word_decr(lock, X_LOCK_HALF_DECR, X_LOCK_HALF_DECR)) {

    /* Decrement occurred: we are the SX lock owner. */
    rw_lock_set_writer_id_and_recursion_flag(lock, !pass);

    lock-&amp;gt;sx_recursive = 1;

  } else {
    /* Decrement failed: It already has an X or SX lock by this
    thread or another thread. If it is this thread, relock,
    else fail. */
    if (!pass &amp;amp;&amp;amp; lock-&amp;gt;recursive.load(std::memory_order_acquire) &amp;amp;&amp;amp;
        lock-&amp;gt;writer_thread.load(std::memory_order_relaxed) ==
            std::this_thread::get_id()) {
      /* This thread owns an X or SX lock */
      if (lock-&amp;gt;sx_recursive++ == 0) {
        lock-&amp;gt;lock_word -= X_LOCK_HALF_DECR;
      }
    } else {
      /* Another thread locked before us */
      return false;
    }
  }
  return true;
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
####SX解锁
如果sx_recursive = 0表示sx锁都释放了，lock_word + X_LOCK_HALF_DECR。如果lock_word &amp;gt; X_LOCK_HALF_DECR 并且waiters = 1说明有写锁等待，通知一下。
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;static inline void rw_lock_sx_unlock_func(
    rw_lock_t *lock) /*!&amp;lt; in/out: rw-lock */
{
  --lock-&amp;gt;sx_recursive;
  if (lock-&amp;gt;sx_recursive == 0) {
    /* Last caller in a possible recursive chain. */
    if (lock-&amp;gt;lock_word &amp;gt; 0) {
      if (rw_lock_lock_word_incr(lock, X_LOCK_HALF_DECR) &amp;lt;= X_LOCK_HALF_DECR) {
        ut_error;
      }
      /* Lock is now free. May have to signal read/write
      waiters. We do not need to signal wait_ex waiters,
      since they cannot exist when there is an sx-lock
      holder. */
      if (lock-&amp;gt;waiters) {
        rw_lock_reset_waiter_flag(lock);
        os_event_set(lock-&amp;gt;event);
        sync_array_object_signalled();
      }
    } else {
      /* still has x-lock */
      ut_ad(lock-&amp;gt;lock_word == -X_LOCK_HALF_DECR ||
            lock-&amp;gt;lock_word &amp;lt;= -(X_LOCK_DECR + X_LOCK_HALF_DECR));
      lock-&amp;gt;lock_word += X_LOCK_HALF_DECR;
    }
  }
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h2 id=&quot;参考资料&quot;&gt;参考资料&lt;/h2&gt;
http://mysql.taobao.org/monthly/2020/04/02/
</description>
        <pubDate>Fri, 19 Nov 2021 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2021/11/19/mysql-rwlock/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2021/11/19/mysql-rwlock/</guid>
        
        
        <category>innodb</category>
        
      </item>
    
      <item>
        <title>mysql8.0 参数解析流程</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#mysql参数&quot; id=&quot;markdown-toc-mysql参数&quot;&gt;mysql参数&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
mysql有很多参数，innodb存储引擎也有自己独立的参数，这篇文章分析一下参数解析的流程。代码版本:8.0.13 &lt;br /&gt;

&lt;h2 id=&quot;mysql参数&quot;&gt;mysql参数&lt;/h2&gt;
my_long_options里面定义了一些不修改，全局，系统启动的时候初始化一次的参数。my_long_options都可以放在sys_var.cc里面&lt;br /&gt;
sys_vars.cc 里面定义了的参数可以动态修改，各种类型都有，可以是全局的，也可以是session级别的，这些参数都是sys_var的子类，所有的参数在构造函数里面都会加到all_sys_vars链表中。 &lt;br /&gt;
在看实际参数之前，我们先学习一下 sys_var类的主要成员变量 &lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;class sys_var {
 public:
  sys_var *next;				//next指针，all_sys_vars链表遍历的时候使用
  LEX_CSTRING name;				//参数名字                     

 protected:

  int flags;                      		//参数标记，比如说global变量，session变量
  int m_parse_flag;               		//PARSE_EARLY 优先解析，PARSE_NORMAL 正常解析.
  my_option option;               		//参数min, max, default值
  ptrdiff_t offset;  				//距离global_system_variables的offset值，实际的参数存储地址空间
  on_check_function on_check;                   //check函数
  on_update_function on_update;                 //update函数
};
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

下面看一个例子：basedir。
我们先看下这个参数的定义
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;static Sys_var_charptr Sys_basedir(
    &quot;basedir&quot;,                                            	//参数名字，和配置文件里面对应
    &quot;Path to installation directory. All paths are &quot;
    &quot;usually resolved relative to this&quot;,                  	//注释
    READ_ONLY NON_PERSIST GLOBAL_VAR(mysql_home_ptr),     	//flag标记，offset偏移量，size
    CMD_LINE(REQUIRED_ARG, &apos;b&apos;), IN_FS_CHARSET, DEFAULT(0));	//参数校验，编码， 默认值
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

参数的flag是read_only + 非持久化 + 全局变量

</description>
        <pubDate>Fri, 20 Aug 2021 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2021/08/20/mysql-option/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2021/08/20/mysql-option/</guid>
        
        
        <category>innodb</category>
        
      </item>
    
      <item>
        <title>mysql8.0 innodb锁相关</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#代码分析&quot; id=&quot;markdown-toc-代码分析&quot;&gt;代码分析&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#os_event_t&quot; id=&quot;markdown-toc-os_event_t&quot;&gt;os_event_t&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#policymutex&quot; id=&quot;markdown-toc-policymutex&quot;&gt;PolicyMutex&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#ttaseventmutex&quot; id=&quot;markdown-toc-ttaseventmutex&quot;&gt;TTASEventMutex&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#sync_array_t&quot; id=&quot;markdown-toc-sync_array_t&quot;&gt;sync_array_t&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#genericpolicy&quot; id=&quot;markdown-toc-genericpolicy&quot;&gt;GenericPolicy&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
innodb里面的mutex常见的实现是PolicyMutex&amp;lt;TTASEventMutex&lt;GenericPolicy&gt;，信号量底层使用是os_event_t&lt;br /&gt;&lt;/GenericPolicy&gt;

&lt;h2 id=&quot;代码分析&quot;&gt;代码分析&lt;/h2&gt;

&lt;h4 id=&quot;os_event_t&quot;&gt;os_event_t&lt;/h4&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;struct os_event {
void set();
int64_t reset();
void wait_low();
void broadcast();
private:
bool m_set;
int64_t signal_count;
os_cond_t cond_var;
EventMutex mutex;
os_cond_t cond_var;
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;ol&gt;
  &lt;li&gt;set函数 如果m_set是false，调用broadcast函数&lt;/li&gt;
  &lt;li&gt;reset函数 设置m_set = false, 返回signal_count&lt;/li&gt;
  &lt;li&gt;wait_low函数 m_set == false 并且signal_count == reset_sig_count 才进入wait, 保证不会死锁&lt;/li&gt;
  &lt;li&gt;broadcast函数 m_set设置true, signal_count计数器+1，唤醒其他等待者&lt;/li&gt;
&lt;/ol&gt;

wait操作: 先调用reset函数，然后用返回的reset_sig_count作为参数，调用wait_low函数 &lt;br /&gt;
signal操作: 调用set函数

&lt;h4 id=&quot;policymutex&quot;&gt;PolicyMutex&lt;/h4&gt;
先看PolicyMutex的主要结构
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;template &amp;lt;typename MutexImpl&amp;gt;
struct PolicyMutex {
private:
MutexImpl m_impl;
public:
void enter();
void exit();
void init();
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
init函数负责初始化，加锁是enter函数，解锁是exit函数，具体的实现都是通过m_impl来实现

&lt;h4 id=&quot;ttaseventmutex&quot;&gt;TTASEventMutex&lt;/h4&gt;
在看TTASEventMutex的主要结构
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;struct TTASEventMutex {
public:
void init();
void exit();
void enter();
bool try_lock();
private:
std::atomic_bool m_lock_word;
std::atomic_bool m_waiters;
os_event_t m_event;
MutexPolicy m_policy;
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
&lt;ol&gt;
  &lt;li&gt;m_lock_word 判断是否加锁成功&lt;/li&gt;
  &lt;li&gt;m_waiters 当前锁有多少个等待者&lt;/li&gt;
  &lt;li&gt;m_event 线程等待内部实现使用&lt;/li&gt;
  &lt;li&gt;m_policy 统计使用&lt;/li&gt;
&lt;/ol&gt;

exit函数
&lt;ol&gt;
  &lt;li&gt;m_lock_word设置false&lt;/li&gt;
  &lt;li&gt;如果有waiter就调用signal函数唤醒其他等待者&lt;/li&gt;
&lt;/ol&gt;

enter函数功能就是加锁，成功返回，否则就一直等待，具体内部实现：
&lt;ol&gt;
  &lt;li&gt;第一步会优先判断m_lock_word原子变量cas操作能否成功，成功就说明加锁成功了，否则说明有其他人持有锁&lt;/li&gt;
  &lt;li&gt;
    调用spin_and_try_lock函数，内部实现死循环执行下面步骤： &lt;br /&gt;

    2.1. 先尝试max_spins次对m_lock_word变量执行cas操作，如果成功就返回 &lt;br /&gt;
 2.2. 没有成功就先尝试执行yield函数，放弃cpu占用 &lt;br /&gt;
 2.3. 调用wait函数，内部实现：&lt;br /&gt;

    &lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt; 2.3.1. 先调用sync_array_get_and_reserve_cell从wait_array获取一个cell，m_waiters设置为true
 2.3.2. 尝试4次m_lock_word原子变量cas操作，如果成功就返回
 2.3.3. 调用sync_array_wait_event等待信号量唤醒
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;    &lt;/div&gt;
  &lt;/li&gt;
&lt;/ol&gt;

&lt;h4 id=&quot;sync_array_t&quot;&gt;sync_array_t&lt;/h4&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;struct sync_array_t {
ulint n_reserved;		//正在使用的cell个数
ulint n_cells;			//数组分配大小   
sync_cell_t *cells;             //数组
ulint next_free_slot;           //除了free list以外，下一个可以用的cell
ulint first_free_slot;          //free list链表头, 复用cell里面的line字段作为next指针
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

sync_array_init			初始化sync_wait_array 二维数组，第一维大小1，第二维大小100k。 &lt;br /&gt;
sync_array_reserve_cell		从sync_wait_array 里面获取一个free cell，极限情况全部cell被占用就返回nullptr &lt;br /&gt;
sync_array_free_cell		放回cell到free list &lt;br /&gt;
sync_array_wait_event		等待信号量唤醒 &lt;br /&gt;

&lt;h4 id=&quot;genericpolicy&quot;&gt;GenericPolicy&lt;/h4&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;struct GenericPolicy {
latch_id_t m_id;
/** Number of spins trying to acquire the latch. */
uint32_t m_spins;

/** Number of waits trying to acquire the latch */
uint32_t m_waits;

/** Number of times it was called */
uint32_t m_calls;
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
每次加锁都会更新里面相关字段,因此通过GenericPolicy可以看到锁竞争激烈程度
</description>
        <pubDate>Sun, 21 Feb 2021 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2021/02/21/mysql-innodb-lock/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2021/02/21/mysql-innodb-lock/</guid>
        
        
        <category>innodb</category>
        
      </item>
    
      <item>
        <title>dead lock2</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#死锁1&quot; id=&quot;markdown-toc-死锁1&quot;&gt;死锁1&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#分析过程&quot; id=&quot;markdown-toc-分析过程&quot;&gt;分析过程&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href=&quot;#结论&quot; id=&quot;markdown-toc-结论&quot;&gt;结论&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#死锁2&quot; id=&quot;markdown-toc-死锁2&quot;&gt;死锁2&lt;/a&gt;    &lt;ul&gt;
      &lt;li&gt;&lt;a href=&quot;#分析过程-1&quot; id=&quot;markdown-toc-分析过程-1&quot;&gt;分析过程&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
最近线上遇到2次报警，登录机器查看，发现所有线程cpu百分比，不响应任何命令，和之前的排查过的&lt;a href=&quot;https://bravoboy.github.io/2018/09/11/rocksdb-deadlock/&quot;&gt;死锁&lt;/a&gt; 很像。&lt;br /&gt;
直接使用pstack命令查看堆栈信息，发现确实出现死锁。&lt;br /&gt;

&lt;h2 id=&quot;死锁1&quot;&gt;死锁1&lt;/h2&gt;

&lt;h4 id=&quot;分析过程&quot;&gt;分析过程&lt;/h4&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;Thread 16 (Thread 0x7fd90920e700 (LWP 20244)):
#0  0x00007fda6e33d222 in pthread_spin_lock () from /lib64/libpthread.so.0
#1  0x00000000008aa7b5 in lock (this=0x2dc4024) at /home/xiaoju/bigdata-storage/fusion.r2/src/spin_lock.h:16
#2  lock_guard (__m=..., this=&amp;lt;synthetic pointer&amp;gt;) at /opt/gcc-5.4/include/c++/5.4.0/mutex:386
#3  ReplicationController::role (this=0x2dc4000) at /home/xiaoju/bigdata-storage/fusion.r2/src/replication.cpp:939
#4  0x000000000081179f in get_self_status () at /home/xiaoju/bigdata-storage/fusion.r2/src/replication.h:666
#5  cmd_proc (req=req@entry=0x6beab6b40) at /home/xiaoju/bigdata-storage/fusion.r2/src/cmds.cpp:191
#6  0x00000000008cbe4f in work_process (work=0x3246000) at /home/xiaoju/bigdata-storage/fusion.r2/src/resp_server.cpp:1588
#7  0x0000000000ca2cc4 in event_persist_closure (ev=&amp;lt;optimized out&amp;gt;, base=0x31618c0) at event.c:1629
#8  event_process_active_single_queue (base=base@entry=0x31618c0, activeq=0x5666cd20, max_to_process=max_to_process@entry=2147483647, endtime=endtime@entry=0x0) at event.c:1688
#9  0x0000000000ca366f in event_process_active (base=0x31618c0) at event.c:1789
#10 event_base_loop (base=0x31618c0, flags=flags@entry=0) at event.c:2012
#11 0x0000000000ca38b7 in event_base_dispatch (event_base=&amp;lt;optimized out&amp;gt;) at event.c:1823
#12 0x00000000008d109a in worker_loop (data=0x3246000) at /home/xiaoju/bigdata-storage/fusion.r2/src/resp_server.cpp:1671
#13 0x0000000000c85245 in g_thread_proxy (data=0xbb68de0) at gthread.c:778
#14 0x00007fda6e338dc5 in start_thread () from /lib64/libpthread.so.0
#15 0x00007fda6d73e21d in clone () from /lib64/libc.so.6
Thread 15 (Thread 0x7fd902e0d700 (LWP 20245)):
#0  0x00007fda6d73e7f3 in epoll_wait () from /lib64/libc.so.6
#1  0x0000000000cac6f4 in epoll_dispatch (base=0x32ac000, tv=&amp;lt;optimized out&amp;gt;) at epoll.c:465
#2  0x0000000000ca3495 in event_base_loop (base=0x32ac000, flags=flags@entry=0) at event.c:1998
#3  0x0000000000ca38b7 in event_base_dispatch (event_base=&amp;lt;optimized out&amp;gt;) at event.c:1823
#4  0x00000000008d109a in worker_loop (data=0x329a000) at /home/xiaoju/bigdata-storage/fusion.r2/src/resp_server.cpp:1671
#5  0x0000000000c85245 in g_thread_proxy (data=0xbb68e30) at gthread.c:778
#6  0x00007fda6e338dc5 in start_thread () from /lib64/libpthread.so.0
#7  0x00007fda6d73e21d in clone () from /lib64/libc.so.6
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;Thread 14 (Thread 0x7fd8fca0c700 (LWP 20246)):
#0  0x00007fda6e33c6d5 in pthread_cond_wait@@GLIBC_2.3.2 () from /lib64/libpthread.so.0
#1  0x0000000000cad515 in evthread_posix_cond_wait (cond_=0x2a7e570, lock_=0x2a7e210, tv=&amp;lt;optimized out&amp;gt;) at evthread_pthread.c:158
#2  0x0000000000c9fde6 in event_del_nolock_ (ev=ev@entry=0x38b3680, blocking=blocking@entry=2) at event.c:2896
#3  0x0000000000ca00b2 in event_del_ (ev=0x38b3680, blocking=2) at event.c:2783
#4  0x0000000000ca012e in event_del (ev=0x38b3680) at event.c:2792
#5  event_free (ev=0x38b3680) at event.c:2233
#6  0x00000000008b0724 in ReplicationController::Promote (this=0x2dc4000) at /home/xiaoju/bigdata-storage/fusion.r2/src/replication.cpp:1039
#7  0x00000000008b4841 in slaveof_impl (ip=&amp;lt;optimized out&amp;gt;, port=&amp;lt;optimized out&amp;gt;) at /home/xiaoju/bigdata-storage/fusion.r2/src/replication.cpp:3002
#8  0x0000000000815d14 in slaveof_cmd (req=0x4a993140) at /home/xiaoju/bigdata-storage/fusion.r2/src/cmds.cpp:5871
#9  0x00000000008904a6 in FusionCommand::process (this=this@entry=0x2dc9758, req=0x4a993140) at /home/xiaoju/bigdata-storage/fusion.r2/src/fusion_command.cpp:19
#10 0x000000000081182f in cmd_proc (req=req@entry=0x4a993140) at /home/xiaoju/bigdata-storage/fusion.r2/src/cmds.cpp:251
#11 0x00000000008cbe4f in work_process (work=0x3288000) at /home/xiaoju/bigdata-storage/fusion.r2/src/resp_server.cpp:1588
#12 0x0000000000ca2cc4 in event_persist_closure (ev=&amp;lt;optimized out&amp;gt;, base=0x32ac2c0) at event.c:1629
#13 event_process_active_single_queue (base=base@entry=0x32ac2c0, activeq=0x5666ce10, max_to_process=max_to_process@entry=2147483647, endtime=endtime@entry=0x0) at event.c:1688
#14 0x0000000000ca366f in event_process_active (base=0x32ac2c0) at event.c:1789
#15 event_base_loop (base=0x32ac2c0, flags=flags@entry=0) at event.c:2012
#16 0x0000000000ca38b7 in event_base_dispatch (event_base=&amp;lt;optimized out&amp;gt;) at event.c:1823
#17 0x00000000008d109a in worker_loop (data=0x3288000) at /home/xiaoju/bigdata-storage/fusion.r2/src/resp_server.cpp:1671
#18 0x0000000000c85245 in g_thread_proxy (data=0xbb68e80) at gthread.c:778
#19 0x00007fda6e338dc5 in start_thread () from /lib64/libpthread.so.0
#20 0x00007fda6d73e21d in clone () from /lib64/libc.so.6
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;

&lt;h4 id=&quot;结论&quot;&gt;结论&lt;/h4&gt;
event_process_active_single_queue回调用户函数卡在业务代码里面的锁,
业务代码另外一个线程先加锁,然后调用了event_free,这个里面又卡在信号量通知，形成死锁。
针对有资源竞争的场景，尽量放到同一个线程执行。

&lt;h2 id=&quot;死锁2&quot;&gt;死锁2&lt;/h2&gt;

&lt;h4 id=&quot;分析过程-1&quot;&gt;分析过程&lt;/h4&gt;
pstack现场没有及时保存，这里代码文字分析一下。&lt;br /&gt;
rocksdb在启动一个Manual-Compact的时候需要先加全局锁，然后调用CompactRange判断对应的区间里面是否和其他compact存在冲突。如果存在冲突就等待&lt;br /&gt;
&lt;div class=&quot;language-plaintext highlighter-rouge&quot;&gt;&lt;div class=&quot;highlight&quot;&gt;&lt;pre class=&quot;highlight&quot;&gt;&lt;code&gt;Status DBImpl::RunManualCompaction(
    ColumnFamilyData* cfd, int input_level, int output_level,
    const CompactRangeOptions&amp;amp; compact_range_options, const Slice* begin,
    const Slice* end, bool exclusive, bool disallow_trivial_move,
    uint64_t max_file_num_to_ignore) {
	//只展示关键代码
	InstrumentedMutexLock l(&amp;amp;mutex_);
	while (!manual.done) {
		assert(HasPendingManualCompaction());
		manual_conflict = false;
		Compaction* compaction = nullptr;
		if (ShouldntRunManualCompaction(&amp;amp;manual) || (manual.in_progress == true) ||
			scheduled ||
			(((manual.manual_end = &amp;amp;manual.tmp_storage1) != nullptr) &amp;amp;&amp;amp;
			 ((compaction = manual.cfd-&amp;gt;CompactRange(
				   *manual.cfd-&amp;gt;GetLatestMutableCFOptions(), manual.input_level,
				   manual.output_level, compact_range_options, manual.begin,
				   manual.end, &amp;amp;manual.manual_end, &amp;amp;manual_conflict,
				   max_file_num_to_ignore)) == nullptr &amp;amp;&amp;amp;
			  manual_conflict))) {
		  // exclusive manual compactions should not see a conflict during
		  // CompactRange
		  assert(!exclusive || !manual_conflict);
		  // Running either this or some other manual compaction
		  bg_cv_.Wait();
		}
	}
}
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;/div&gt;
我们代码里面自定义了Filter类,在过滤的时候会调用write接口,向db写入数据，写操作是需要申请加锁的。&lt;br /&gt;
有一个正在跑着的compact线程，在filter过滤数据的时候，会写数据，卡在全局锁上面。&lt;br /&gt;
新的Manual-Compact持有全局锁，但是在等待其他compact完成，又卡在信号通知上面。&lt;br /&gt;
修改方法就是把自定义Filter类中写操作，放到异步队列当作，不在本线程。
</description>
        <pubDate>Mon, 04 May 2020 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2020/05/04/rocksdb_deadlock2/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2020/05/04/rocksdb_deadlock2/</guid>
        
        
        <category>rocksdb</category>
        
      </item>
    
      <item>
        <title>rocksdb blob</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#写流程&quot; id=&quot;markdown-toc-写流程&quot;&gt;写流程&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#读流程&quot; id=&quot;markdown-toc-读流程&quot;&gt;读流程&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#gc流程&quot; id=&quot;markdown-toc-gc流程&quot;&gt;gc流程&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#限制&quot; id=&quot;markdown-toc-限制&quot;&gt;限制&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#参考资料&quot; id=&quot;markdown-toc-参考资料&quot;&gt;参考资料&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
最近线上遇到一个业务，平均value很大，达到50K，写放大很严重。&lt;br /&gt;
blob_db参考了WiscKey的思想，设计的kv存储分离，可以有效的减小写放大。&lt;br /&gt;
LSM树里面只存储key和value的地址，这样后台线程compact的时候可以少读写很多数据。&lt;br /&gt;
rocksdb里面增加一种类型：kTypeBlobIndex 表示value是否blob_db的地址。 &lt;br /&gt;

&lt;h2 id=&quot;写流程&quot;&gt;写流程&lt;/h2&gt;
首先判断value大小是否超过配置，超过了就写blob_db，然后在把offset和文件id做为value写入lsm树。&lt;br /&gt;
否则就是正常的rocksdb写入。如果设置了db最大size，并且磁盘空间超过限制了，就会淘汰删除最老的blob文件。&lt;br /&gt;
blob文件格式：&lt;br /&gt;
head结构 &lt;br /&gt;
|—-|—-|—-|-|-|——–|———|  &lt;br /&gt;
magic version cf_id flag expiration_start expiration_end &lt;br /&gt;
foot结构 &lt;br /&gt;
|—-|——–|——–|———|—-|  &lt;br /&gt;
magic count expiration_start expiration_end crc &lt;br /&gt;

和sst文件一样，blob文件写完以后，不会被更改，只能被删除。&lt;br /&gt;
每个blob文件都有size限制，超过这个限制就会和wal一样，重新打开一个blob文件写入。&lt;br /&gt;
每个blob文件没有类似rocksdb那样的level层级。&lt;br /&gt;

&lt;h2 id=&quot;读流程&quot;&gt;读流程&lt;/h2&gt;
主要的流程还是和普通的db一样，增加GetImplOptions里面is_blob_index选项。&lt;br /&gt;
BlobDBOptions选项里面min_blob_size控制多大的value存储在blob_db中，小于min_blob_size，还是和原来一样，存储在lsm树。&lt;br /&gt;
根据返回的value类型判断，如果是kTypeBlobIndex，那么就需要再从blob_db获取真正的value，可以看到比原来多了一次读。&lt;br /&gt;
先需要解码lsm树里面获取的value,找到对应的blob_db里面的文件和offset,然后再获取真正的数据。&lt;br /&gt;

&lt;h2 id=&quot;gc流程&quot;&gt;gc流程&lt;/h2&gt;
每个blob文件或者会有几个对应的sst文件，或者对应几个memtable。&lt;br /&gt;
只有blob文件没有关联的sst文件并且blob文件的seq比flush_seq大，才满足被gc删除条件。&lt;br /&gt;
后台线程会周期性的删除无用的blob文件。&lt;br /&gt;
Flush memtable的时候会跟进value类型判断，如果valuekTypeBlobIndex，则会更新文件对应的最早的blob文件。&lt;br /&gt;
Flush完成以后会调用blob的回调函数，建立新的sst文件和blob文件的对应关系。&lt;br /&gt;
Compact完成以后也会调用blob的回调函数，老的sst文件和blob文件映射关系解除，增加新的sst文件和blob文件的映射关系。&lt;br /&gt;

&lt;h2 id=&quot;限制&quot;&gt;限制&lt;/h2&gt;
&lt;ol&gt;
  &lt;li&gt;只支持单cf&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&quot;参考资料&quot;&gt;参考资料&lt;/h2&gt;
&lt;ul&gt;
  &lt;li&gt;https://www.usenix.org/system/files/conference/fast16/fast16-papers-lu.pdf&lt;/li&gt;
  &lt;li&gt;https://www.jianshu.com/p/24152a212296&lt;/li&gt;
&lt;/ul&gt;
</description>
        <pubDate>Tue, 21 Apr 2020 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2020/04/21/rocksdb_blob/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2020/04/21/rocksdb_blob/</guid>
        
        
        <category>rocksdb</category>
        
      </item>
    
      <item>
        <title>最近遇到linux问题总结</title>
        <description>&lt;ul id=&quot;markdown-toc&quot;&gt;
  &lt;li&gt;&lt;a href=&quot;#背景&quot; id=&quot;markdown-toc-背景&quot;&gt;背景&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#机器网络丢包&quot; id=&quot;markdown-toc-机器网络丢包&quot;&gt;机器网络丢包&lt;/a&gt;&lt;/li&gt;
  &lt;li&gt;&lt;a href=&quot;#服务进程启动不了&quot; id=&quot;markdown-toc-服务进程启动不了&quot;&gt;服务进程启动不了&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;h2 id=&quot;背景&quot;&gt;背景&lt;/h2&gt;
最近遇到2个线上问题，记录一下，总结经验。&lt;br /&gt;
&lt;ol&gt;
  &lt;li&gt;机器网络丢包&lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;服务进程启动不了&lt;br /&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;h2 id=&quot;机器网络丢包&quot;&gt;机器网络丢包&lt;/h2&gt;
有业务反馈线上服务有时候查询不出来结果，自己用业务反馈的请求，试了几次果真会出现查询不到的问题。&lt;br /&gt;
先说一下我们的整体架构，最上层是vip，负责负载均衡和机器谈话，中间是proxy，底层才是实际的存储服务节点。&lt;br /&gt;
排查过程: &lt;br /&gt;
&lt;ol&gt;
  &lt;li&gt;绕过vip，直接访问proxy，发现有一个proxy每次查询都不能返回结果，必现。其他的proxy都很正常。&lt;/li&gt;
  &lt;li&gt;立即从vip摘除这个proxy，业务那边也反馈问题恢复了。&lt;/li&gt;
  &lt;li&gt;登录有问题的机器，tcpdump抓包，发现proxy请求另外一个服务A的时候，返回的数据包不对，出现丢包现象，下图1。&lt;/li&gt;
  &lt;li&gt;在正常的机器也用tcpdump抓包，对比结果，确认是返回数据出现丢包了。&lt;/li&gt;
  &lt;li&gt;登录服务A的机器准备在那边也抓包看看，发现出现tcp 200ms超时重传，下图2。&lt;/li&gt;
  &lt;li&gt;对比有问题机器和没问题机器的网络配置，发现mtu值不一样，有问题的机器是1600，正常机器是1500，服务A的机器mtu也是1600。&lt;/li&gt;
  &lt;li&gt;咨询了网络组同事，vip机器的mtu也是1500, 修复有问题机器的mtu为1500，问题修复。&lt;br /&gt;&lt;/li&gt;
&lt;/ol&gt;

图1：&lt;br /&gt;
&lt;img src=&quot;/images/mtu1.png&quot; alt=&quot;pic2&quot; /&gt;
我们可以看到3次握手成功以后，客户端36972端口发送了一个请求，服务端3028端口回报了，但是回报的seq号和前面不连续。&lt;br /&gt;
3次握手里面3028端口发送的seq是4072672142，但是看3028端口回的数据包的seq是4022679883，明显中间有丢包了。当然有可能是tcpdump抓包的时候丢的。&lt;br /&gt;

图2：&lt;br /&gt;
&lt;img src=&quot;/images/mtu2.png&quot; alt=&quot;pic2&quot; /&gt;
看图中的红框，出现了tcp经典的200ms重传。验证了图1所说的丢包问题。图1和图2，端口对不上的原因是中间还有一层vip服务。&lt;br /&gt;
最后解释一下原因：&lt;bt&gt;&lt;/bt&gt;
tcp3次握手时候会协商mss大小，一般是本机mtu-40(包头)，vip的机器在3次握手的时候是透传了tcp的option选项。&lt;br /&gt;
mss值会取客户端和服务器之间的最小值，mtu为1600机器之间协商出来的mss大小1540，mtu1500和mtu1600机器协商是1440。&lt;br /&gt;
所以2台mtu1600之间传输大包的时候会在vip机器进行分片，分片之后的包没有4层头信息，所以没办法顺利转发，出现丢包现象。&lt;br /&gt;
不知道这算不算vip的问题，在tcp3次握手的时候，没有把本机的mtu值传给通信双方。&lt;br /&gt;

&lt;h2 id=&quot;服务进程启动不了&quot;&gt;服务进程启动不了&lt;/h2&gt;
某天组内同事服务的时候，发现有一台机器突然出现出core，其他机器正常，而且诡异的是出core是另外的服务，和本次升级服务，没有任务逻辑关系。&lt;br /&gt;
排查过程： &lt;br /&gt;
&lt;ol&gt;
  &lt;li&gt;先让同事暂停操作，登录机器查看core文件没有发现有价值信息，supervised拉起服务以后马上又core。&lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;尝试手动启动服务，发现问题了，进程资源受限，rocksdb后台线程创建不了。&lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;使用ulimit -a命令看到当前账户的最大进程数1024，使用pstree命令查看当前账户的进程情况，刚好同事升级了另外服务，新版本会多创建几个线程，触发上限了，导致其他服务出现core，莫名躺枪。其他正常机器这个值都是4096。&lt;br /&gt;&lt;/li&gt;
  &lt;li&gt;使用root命令修改limits.conf里面的限制，切回到原来账户发现并不生效，在网上搜索到一篇&lt;a href=&quot;https://www.cnblogs.com/ymei/p/11776582.html&quot;&gt;文章&lt;/a&gt;，按照教程修改了一下，生效。重启服务解决问题 &lt;br /&gt;&lt;/li&gt;
&lt;/ol&gt;

</description>
        <pubDate>Sat, 21 Mar 2020 00:00:00 +0000</pubDate>
        <link>https://bravoboy.github.io/2020/03/21/linux-problem/</link>
        <guid isPermaLink="true">https://bravoboy.github.io/2020/03/21/linux-problem/</guid>
        
        
        <category>linux</category>
        
      </item>
    
  </channel>
</rss>
