LLM 强大的语言、知识与推理能力在改变很多领域，也将持续、深入的改变更多领域。在软件领域，“Agent” 的编程模型已经是一种新的编程模式，通过这种“模式”可以将 LLM 的能力，软件提供商的领域知识，以及外部工具的能力很好的结合起来，形成“新的”软件产品。

在 \( \text{Attention} \) 机制（或 \( \text{Multi-Head Attention} \) ）中我们会看到这样的变换：\( \text{Attention} = softmax(\frac{Q_iK_i^{T}}{\sqrt{d}}) \)，其中这里 \( Q_i = XW_i^Q \) 那么如何理解这里的 \( XW_i^Q \) 呢？ 该变换是向量空间内一个典型的线性变换，而这里的 \( W_i^Q \) 就是对应的线性变换矩阵，在早期 GPT 模型中该矩阵是一个\( 768 \times 64\) 的矩阵，研究该矩阵的典型方法就可以使用 \( \text{SVD} \) 分解，本文展示了简单的二维空间中 \( \text{SVD} \) 分解以及对应的几何意义，从而可以较好的帮助理解上述计算的深层次含义。

关于奇异值分解（\( \text{SVD} \)）能够解决的问题这里不再详述。本文通过展示对于平面空间中的线性变换进行奇异值分解，从而观察该分解如何通过“几何”的方式描述一个线性变换，从而建立对线性变换的直观理解。本文的示例是一个\( 2 \times 2\)的矩阵，所以还补充了对该矩阵的特征值/特征向量的计算，从而对比这两种方法在处理“方阵”时的异同。

1. 概述

本文通过对二维空间中的一个线性变换（满秩方阵） \( A = \begin{bmatrix} 1 & 2 \\ 2 & 1 \end{bmatrix} \) 进行 \( \text{SVD} \) 分析、特征值/特征向量分析，从而建立在平面空间中对于线性变换的直觉理解，更进一步的理解\( \text{SVD} \)和特征值/特征向量分别是如何描述一个线性变换的。具体的，这里观察了在该线性变换的作用下，一个点 \( (1,0) \) 是如何在两种矩阵变换下，映射到目标点的。

2. 奇异值分解

2.1 矩阵A的两种 SVD 分解

奇异值分解并不是唯一的。从几何的角度理解，一个二维空间的线性变换，是由旋转、反射、缩放组成，而先旋转、或先反射都是可以的，而这对应的就是不同的奇异值分解。考虑上述的矩阵 \( A = \begin{bmatrix} 1 & 2 \\ 2 & 1 \end{bmatrix} \) 进行 \( \text{SVD} \)，我们有如下两种分解（关于具体的分解方法，本文并不详述）。

第一种分解：

$$ A = \begin{bmatrix}
1 & 2 \\
2 & 1
\end{bmatrix} = UΣV^T =\begin{bmatrix}
\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\
\frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}}
\end{bmatrix}\begin{bmatrix}
3 & 0 \\
0 & 1
\end{bmatrix}\begin{bmatrix}
\frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \\
\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}}
\end{bmatrix}
$$

第二种分解如下：

$$ A = \begin{bmatrix}
1 & 2 \\
2 & 1
\end{bmatrix} = UΣV^T =\begin{bmatrix}
-\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\
-\frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}}
\end{bmatrix}\begin{bmatrix}
3 & 0 \\
0 & 1
\end{bmatrix}\begin{bmatrix}
-\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\
\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}}
\end{bmatrix} $$

2.2 分解1的几何意义与图示

$$ A = \begin{bmatrix}
1 & 2 \\
2 & 1
\end{bmatrix} = U\Sigma V^T = \begin{bmatrix}
\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\
\frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}}
\end{bmatrix}\begin{bmatrix}
3 & 0 \\
0 & 1
\end{bmatrix}\begin{bmatrix}
\frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \\
\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}}
\end{bmatrix}
$$

考虑：

\( V^T = \begin{bmatrix} \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}}\end{bmatrix} \) 形式与 \( \begin{bmatrix} \cos \varphi & \sin\varphi \\ \sin\varphi & -\cos \varphi \end{bmatrix} \) 相同，故，此为关于直线 \( y = (\tan\frac{\varphi}{2})x \) 的反射^[附录1]。

\( \Sigma = \begin{bmatrix} 3 & 0 \\ 0 & 1 \end{bmatrix} \) 表示将点、向量的坐标进行缩放。

\( U = \begin{bmatrix} \frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \end{bmatrix} \) 形式与 \( \begin{bmatrix} \cos \varphi & -\sin\varphi \\ \sin\varphi & \cos \varphi \end{bmatrix} \) 相同，故，此为一个逆时针 \( \varphi \) 度的旋转^[附录1]。

即，上述的线性变换可以做这样的理解：

• 先将点以\( y=\tan\frac{45}{2}x = (\sqrt{2}-1)x \)为轴进行反射
• 然后将坐标第一个分量放大3倍
• 最后再逆时针旋转\( 45^{\circ} \)

考虑坐标上的点\( \alpha = \begin{pmatrix} 1 \\ 0 \end{pmatrix} \)，我们看看如何经过该线性变换，映射到目标点：

右图反映了完整的过程：

• \( (1,0) \) 先经过按图中虚线为轴进行反射，到红点
• 然后，进行拉伸，第一个分量拉伸3倍，到绿色点
• 最后，再逆时针旋转\( 45^{\circ} \) 到黄色点

对应的矩阵计算如下：

\( \text{red} = V^T \alpha = \begin{bmatrix} \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}}\end{bmatrix} \begin{pmatrix} 1 \\ 0 \end{pmatrix} = \begin{pmatrix} \frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} \end{pmatrix} \)

\( \text{green} = \Sigma V^T \alpha = \Sigma \, \text{red} = \begin{bmatrix} 3 & 0 \\ 0 & 1 \end{bmatrix} \begin{pmatrix} \frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} \end{pmatrix} = \begin{pmatrix} \frac{3}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} \end{pmatrix} \)

\( \text{yellow} = U\Sigma V^T \alpha = U \, \text{green} = \begin{bmatrix} \frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \end{bmatrix} \begin{pmatrix} \frac{3}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} \end{pmatrix} = \begin{pmatrix} 1 \\ 2 \end{pmatrix} \)

2.3 分解2的几何意义与图示

$$ A = \begin{bmatrix}
1 & 2 \\
2 & 1
\end{bmatrix} = UΣV^T =\begin{bmatrix}
-\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\
-\frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}}
\end{bmatrix}\begin{bmatrix}
3 & 0 \\
0 & 1
\end{bmatrix}\begin{bmatrix}
-\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\
\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}}
\end{bmatrix} $$

考虑：

\( V^T = \begin{bmatrix}-\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \end{bmatrix} \) 形式与 \( \begin{bmatrix} \cos \varphi & -\sin\varphi \\ \sin\varphi & \cos \varphi \end{bmatrix} \)相同，故，此为一个逆时针 \( \varphi = 135^{\circ} \) 度的旋转^[附录1]。

\( \Sigma = \begin{bmatrix} 3 & 0 \\ 0 & 1 \end{bmatrix} \) 表示将点、向量的坐标进行缩放。

\( U = \begin{bmatrix} -\frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}} \\ -\frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \end{bmatrix} \) 形式与 \( \begin{bmatrix} \cos \varphi & \sin\varphi \\ \sin\varphi & -\cos \varphi \end{bmatrix} \) 相同，故，此为关于直线 \( y = (\tan\frac{\varphi}{2})x \) 的反射^[附录1]。

即，上述的线性变换可以做这样的理解：

• 点\( (1,0) \) 先逆时针旋转\( \varphi = 135^{\circ} \)到达红色点
• 然后将坐标第一个分量放大3倍，成为绿色点
• 最后将点以\( y=\tan\frac{-135^{\circ}}{2}x \)为轴进行反射，到黄色点

具体可以参考右图，详细的计算这里不再给出。

3. 特征值与特征向量

因为这里的\( A \)是一个 \( 2 \times 2 \) 的方阵，故可以使用特征值与特征向量来洞察这个线性变换的本质。

对于该矩阵的特征值、对应的特征向量计算结果如下：

• 对于特征值 \( \lambda_1 = 3 \) 时，特征向量为 \( (\frac{1}{\sqrt{2}}, \frac{1}{\sqrt{2}}) \)
• 对于特征值 \( \lambda_2 = -1 \) 时，特征向量为 \( (\frac{1}{\sqrt{2}}, -\frac{1}{\sqrt{2}}) \)

依旧，这里我们来考虑向量 \( \alpha = \begin{pmatrix} 1 \\ 0 \end{pmatrix} \) 在这两个特征向量方向上作用后的效果。

右图已经比较直观的反应了如何从特征向量和特征值的角度去理解线性变换：

• 首先，先将向量 \( \alpha \) 在两个特征向量上进行分解，分解后的向量分别为 \( \alpha_1 \, \alpha_2 \)
• 然后再按照特征值进行缩放：
  • \( \lambda_1 = 3 \) 故将 \( \alpha_1\)拉伸为 \( \beta_1 \)
  • \( \lambda_2 = -1 \) 故将 \( \alpha_2\)反向为 \( \beta_2 \)
• 最后，\( \beta_1 \) 和 \( \beta_2 \) 合并为 \( \beta \)

4. 小结

在这种情况下（注：线性变换矩阵为一个 \( 2 \times 2 \)的满秩矩阵）， 我们可以使用奇异值分解\( \text{SVD} \)、特征值计算的方式来洞察这个线性变换的“本质”。两种方法各有一些优缺点，大家可以自己去体会，这里小结一下我的理解。

奇异值分解\( \text{SVD} \)是一种“动态”的展示线性变换的方法，可以让你很清晰的了解这个线性变换是如何将空间中的“一个点”映射到“另一个点”的。例如在上述的例子中，则是先进行旋转、然后进行缩放、最后进行反射。

特征值/特征向量计算则是对线性变换的“静态”解释，使用静态的方式展现了线性变换如何将“一个点”映射到“另一个点”的。

5. 补充说明

• 实际应用中的奇异值分解通常是用于处理更高维的向量空间，所以通常没有这么直观的几何意义，但是依旧可以使用类比的“反射”、“旋转”、“拉伸/压缩”等概念去扩展的理解。
• 特征值/特征向量仅适用于处理方阵的场景，所以场景比较受限。
• 关于特特征值/特征向量计算，在实际中可能会更加复杂，例如，重根、复数根等情况，要想进一步理解，则需要做更深入的研究。
• 要进一步加深理解，则可以考虑，观察一个三维空间中变换的实例，有一些相同，也有一些不同：
  • 反射，通常是基于某个平面（两个基张成的平面）的
  • 选择，则是绕着某个直线（某个向量的方向上）

附录1 二维空间的正交变换

二维空间中，有两种正交变换，即旋转或反射。其对应的线性变换矩阵分别有如下的形式：\( \begin{bmatrix} \cos \varphi & \sin\varphi \\ \sin\varphi & -\cos \varphi \end{bmatrix} \) 与 \( \begin{bmatrix} \cos \varphi & -\sin\varphi \\ \sin\varphi & \cos \varphi \end{bmatrix} \) 。

附录2 三维空间的正交变换

在三维空间内，对于一组规范正交基 \( \{ \alpha_1,\alpha_2,\alpha_3 \} \) ，该空间下的正交变换矩阵总有如下形式：

$$
\begin{bmatrix}
\pm 1 & 0 & 0 \\
0 & a & b \\
0 & c & c
\end{bmatrix}
$$

更为具体的为如下三种形态之一：

$$
A = \begin{bmatrix}
1 & 0 & 0 \\
0 & \cos\varphi & -\sin\varphi \\
0 & \sin\varphi & \cos\varphi
\end{bmatrix}
\quad
B = \begin{bmatrix}
-1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{bmatrix}
\\
\begin{aligned}
C & = \begin{bmatrix}
-1 & 0 & 0 \\
0 & \cos\varphi & -\sin\varphi \\
0 & \sin\varphi & \cos\varphi
\end{bmatrix} \\
& =
\begin{bmatrix}
1 & 0 & 0 \\
0 & \cos\varphi & -\sin\varphi \\
0 & \sin\varphi & \cos\varphi
\end{bmatrix}
\begin{bmatrix}
-1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{bmatrix}
\end{aligned}
$$

这里的：

• 变换 \( A \) 为一个旋转，旋转轴为 \( \alpha_1 \) 所在的直线
• 变换 \( B \) 是一个反射，反射轴平面为 \( \mathscr{L}(\alpha_2,\alpha_3) \)
• 变换 \( C \) 是上述两个变换的组合

这大概是一个有趣、也略深刻的发现。

Word Embedding是比较抽象的，但是这些抽象背后是一些“具象”的含义的，本文通过一些简单的计算（变换）来将Embedding的某些维度/属性具象化。具体的，本文展示了在Embedding空间中，找到一个代表“动物”属性的方向。感兴趣的话，可以通过这个简单的方法，找到你感兴趣的属性方向。

TL;DR

通常，在某个具体的Word Embedding实现中，先给出一组具有“共同属性”的词语，然后计算这组词语Embedding向量的平均方向，就可以代表这个“共同属性”。

例如，找到一组“动物”，然后对这些词语的Embedding向量计算平均方向，那么这个方向就是“动物”这个属性的方向。

概述

如果你也尝试过去理解 Embedding 各个维度的含义的话，大概都听过这样一种说法：Embedding每个维度可以理解为这个词语的某种属性，例如，“性别属性”、“皇室相关度”等，这是最为经典的man - woman = king - queue的例子中的一些解释。

当你真的拿到一个词语的 Embedding 的时候，它可能有768维，但是，似乎没有一个维度有上述的清晰的属性含义。而实际上，这些属性含义是确实存在的，只是这些属性方向并不存在于“标准基”的方向上。

那如果存在，我们应该如何找到这个方向呢？本文展示并验证了一个非常简单的方法，让你快速找到某种属性的方向，并且进行一些验证。从而可以大大加深对于 Embedding 的理解。

寻找某个关心的方向

这里展示了以寻找“动物”属性方向为例，展示如何寻找并验证该方向。

列出最具代表性的词语

我们这样考虑这个问题，如果有一个方向表示一个词语的“动物”属性，那么这个方向会是哪个方向？这里以all-MiniLM-L6-v2模型提供的Sentence Embedding为例，我看看如何找到该Embedding所处的向量空间中最可能代表“动物”属性的方向是哪个？具体的方法描述如下：

• 首先，找到被认为最典型的与“动物”属性相关的词语\( n \)个，这里取\( n=50 \)
• 然后计算上述\( n \)个词语的平均方向 avg_vector，该方向则认为要寻找的方向

这里，给出的50个动物如下：

animals = [
    "tiger", "lion", "elephant", "giraffe", "zebra",
    "rhinoceros", "hippopotamus","crocodile", "monkey",
    "panda", "koala", "kangaroo","whale", "dolphin",
    "seal", "penguin", "shark", "snake", "lizard",
    "turtle", "frog", "butterfly", "bee", "ant", "eagle",
    "sparrow", "pigeon", "parrot", "owl", "duck", "chicken",
    "dog", "cat", "pig", "cow", "sheep", "horse", "donkey",
    "rabbit", "squirrel", "fox", "wolf", "bear", "deer",
    "hedgehog", "bat", "mouse", "chameleon", "snail", "jellyfish"
]

计算Embedding的平均方向

该平均方向，即为我们要寻找的“动物”属性方向。

animals_embeddings = model.encode(animals)
avg_animals_embeddings = np.mean(animals_embeddings, axis=0)

验证该方向

再选取两组词，一组认为是与“动物”非常相关的词，另一组则是与动物无关的词语。然后分别计算这两组词语在上述方向avg_vector的投影值。观察投影值，是否符合预期。

这里选择的两组词语分别是：

• 与动物非常相关的：”Camel”, “Gorilla”, “Cheetah”
• 与动物无关的：”Dream”, “Chair”, “Mathematics”

计算投影并可视化

具体的程序如下：

animals_words    = ["Camel", "Gorilla", "Cheetah"]
un_animals_words = ["Dream", "Chair", "Mathematics"]

for word_list in (animals_words,un_animals_words):
    projection_scores = np.dot(model.encode(word_list),
                              avg_animals_embeddings)
    results.update({word: score for word,
                    score in zip(word_list, projection_scores)})

for word, score in results.items():
    print(f"'{word}': {score:.4f}")
print(np.round(avg_animals_embeddings[:10], 4))

投影结果为：

'Camel': 0.3887
'Gorilla': 0.4186
'Cheetah': 0.3797
'Dream': 0.2450
'Chair': 0.2823
'Mathematics': 0.1972

在实数轴上绘制上述两组词语的投影：

非常明显的可以看到，上述的avg_vector方向某种程度上代表了一个词语的“动物”属性：即与动物属性相关的词语在该方向的投影大，无关的词语在该方向的投影小。

原理解释

概述

事实上，一组词语Embedding的“平均向量”（centroids of word embeddings），则某种程度的代表这组词语的“语义中心”。如果这组词有某些共性，那么这个平均向量，则可能就是这个共性的代表。

在上述的例子中，刻意地给出的一组词语都是“动物”名称。那么，这个“平均向量”则比较有可能代表了这个向量空间中的“动物”属性。

数学推导

这样考虑这个问题：现在给出的 \( n \) 个向量 \( \alpha_1, \dots , \alpha_n \)，找出一个单位向量 \( \xi \) 使得 \( n \) 个向量在 \( \xi \) 向量方向上的投影值的和最大。

这里取 \( \bar{\alpha} = \frac{\sum\limits_{i=1}^{n}\alpha_i}{n} \)

目标函数 \( S = \sum\limits_{i=1}^{n}(\alpha_i \cdot \xi ) = \sum\limits_{i=1}^{n}(\alpha_i) \cdot \xi = n \bar{\alpha} \cdot \xi = n \| \bar{\alpha}\| \| \xi \| \cos\theta \)

这里 \( n \)、\( \bar{\alpha} \)都是给定值，而 \( \| \xi \| = 1 \)，所以这里 \( \cos\theta \) 取最大值时，上述的目标函数 \( S \) 取最大值。

即：\( \theta = 0 \) 时， \( S \) 取最大值。即当 \( \xi \) 与 \( \bar{\alpha} \) 方向相同时，即 \( \xi = \frac{\bar{\alpha}}{\|\bar{\alpha}\|} \) ，所有向量的投影值的和最大。

投影计算

太久不碰线性代数了，对于基本运算都不是很熟悉了。向量 \( \alpha \) 在 \( \beta \) 方向上的投影长度，计算公式如下：

$$ proj = \frac{\alpha \cdot \beta}{\|\beta\|} $$

证明比较简单，这里不再赘述。

向量的平均方向与主成分方向

当给出一组向量，面对上述问题，比较容易联想到这组向量的“主成分分析”的第一个维度。那么，上述的平均向量和主成分分析的第一个维度有什么关系呢？回答是：没有太大的关系。

可以看下面三个图：

上述三个二维平面中的点的平均方向均为红色，即(1,1)；但是PCA的第一方向则各有不同，有时候与平均向量相同、有时候垂直，有时候相交。总之是没什么关系。

可以看到，平均向量时在当前的“基”下计算获得。而主方向分析的方向，则首先就与原点没有关系。

更深层次的理解

现在的Embedding算法，都是基于现实世界语料库训练而来，反应了人类认知中“语言”与现实世界的对应关系。而在人类的认知中，这个世界是有“维度”的，最为直白的例子就是：我们会将词语划分“褒义词”、“贬义词”。此外，可能还有：动物性、情感强烈度、词性等。那么，在人类认知中这种“认知”有多少个维度呢？这其实是未知的，而各种Embedding算法则是在尝试使用量化的方式描述这些维度。

但是，在实际训练出的各种Embedding实现，例如一个768维的Embedding，其单位向量方向，不太可能是上述的人类“认知”维度。如果把训练出来的Embedding的单位向量记为：\( \alpha_1, \dots , \alpha_n \)，而把人类认知的维度记为： \( \beta_1, \dots , \beta_n \) 。

那么，则存在一个过渡矩阵 $T$，可以实现上述向量空间基的变换。

可是，现实世界没有那么理想。Embedding空间确实给出了一组正交基，但是人类认识却很难寻找这样的正交基，例如“动物”属性的词语，可能会带有“情感”属性，例如，“虎狼之词”等，都带有某种情感属性。

虽然，认知很难找到正交的“基”，但是找到某个具体的属性方向，则可以使用本书的方法。这正是本文所描述方法的局限性和价值所在。

补充说明

• 本文中，所说的Word Embedding，通常是指Sentence Embedding中的Token Embedding。在这里，无需区分两者。
• 实际的情况更加复杂，例如本文中的“动物”属性，只是这些词所代表的“动物”属性。什么是真正的“动物”属性，并不存在这样的精确概念。人类语言中的“动物”是一个抽象的，并没有数字化、数学化的精确定义。
• 完整的实现代码，参考：embedding_research_01.py。

InnoDB 的锁容易被忽略的细节是关于“隐式锁”（即：implicit locks）的存在。表现上，有的锁是存在的，但在使用SHOW ENGINE INNODB STATUS或者performance_schema.data_locks中却查看不到。最为常见的隐式锁是在写入（INSERT）时，当前事务会持有该记录对应的锁，但是在系统中，通常是查看不到的。但，如果发生了该锁冲突（或竞争）时，系统中则可以看到此类锁信息。

本文重现了较为常见的隐式锁场景，包括：数据写入（INSERT）时的隐式锁、根据主键操作是可能产生的二级索引隐式锁等。帮助开发者能够更系统的理解，InnoDB 的锁机制。

写入数据产生的隐式锁

准备数据

DROP TABLE IF exists t1;

 CREATE TABLE `t1` (
  `id` int unsigned,
  `nick` varchar(32),
  `age` int,
  UNIQUE KEY `uk_n` (`nick`)
);

mysql> desc t1;
+-------+--------------+------+-----+---------+
| Field | Type         | Null | Key | Default |
+-------+--------------+------+-----+---------+
| id    | int unsigned | YES  |     | NULL    |
| nick  | varchar(32)  | YES  | UNI | NULL    |
| age   | int          | YES  |     | NULL    |
+-------+--------------+------+-----+---------+

mysql> INSERT INTO t1 VALUES (1, 'a' , 12),(20,'z',29);
Query OK, 2 rows affected (0.01 sec)
Records: 2  Duplicates: 0  Warnings: 0

mysql> select * from t1;
+------+------+------+
| id   | nick | age  |
+------+------+------+
|    1 | a    |   12 |
|   20 | z    |   29 |
+------+------+------+
2 rows in set (0.00 sec)

构建隐式锁

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO t1 VALUES (8, 'h' , 32);
Query OK, 1 row affected (0.00 sec)

查看锁信息：

> SELECT 
    ENGINE_TRANSACTION_ID AS TRX_ID,
    OBJECT_NAME,
    INDEX_NAME,
    LOCK_TYPE,
    LOCK_MODE,
    LOCK_STATUS,
    LOCK_DATA 
  FROM performance_schema.data_locks;
+--------+-------------+------------+-----------+-----------+-------------+-----------+
| TRX_ID | OBJECT_NAME | INDEX_NAME | LOCK_TYPE | LOCK_MODE | LOCK_STATUS | LOCK_DATA |
+--------+-------------+------------+-----------+-----------+-------------+-----------+
|  10165 | t1          | NULL       | TABLE     | IX        | GRANTED     | NULL      |
+--------+-------------+------------+-----------+-----------+-------------+-----------+

可以看到，在 data_locks 表中没有任何关于事务中写入数据相关的锁。这是，因为这是一个隐式的锁，在没有任何锁竞争的情况下，系统并不会将该类型的锁展示出来（注：这可能与底层的存储和实现有关，隐式锁在实现上可能就没有“显式”的存储在锁相关的数据结构中）。

构建锁竞争/隐式转显式

这里通过在另一个事务中尝试并发写入一条冲突的记录，来构建锁竞争：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO  t1 VALUES (9,'h',17);
...

该事务执行时，则会陷入锁等待。这时，再次查看锁信息如下：

+--------+-------------+------------+-----------+---------------+-------------+---------------------+
| TRX_ID | OBJECT_NAME | INDEX_NAME | LOCK_TYPE | LOCK_MODE     | LOCK_STATUS | LOCK_DATA           |
+--------+-------------+------------+-----------+---------------+-------------+---------------------+
|  10165 | t1          | NULL       | TABLE     | IX            | GRANTED     | NULL                |
|  10168 | t1          | NULL       | TABLE     | IX            | GRANTED     | NULL                |
|  10165 | t1          | uk_n       | RECORD    | X,REC_NOT_GAP | GRANTED     | 'h', 0x000000000214 |
|  10168 | t1          | uk_n       | RECORD    | S             | WAITING     | 'h', 0x000000000214 |
+--------+-------------+------------+-----------+---------------+-------------+---------------------

这时候，可以看到事务10165，持有一个记录锁，该锁是一个排它记录锁（X,REC_NOT_GAP ），加锁对象是'h', 0x000000000214（注，这是一个唯一索引的入口，前面'h'是唯一索引值，后面的0x000000000214部分是该表的InnoDB内置rowid）。

主键/二级索引操作相关的隐式锁

InnoDB 的锁管理和实现确实一个超级复杂的部分（”mega-complicated“）。隐式锁的使用场景也非常多，如果对此不了解的话，那么在观察 InnoDB 的锁信息时，是会有很多的困惑的。这里再列举一类也算，较为常用的隐式锁：“主键索引/二级索引”相关的隐式说。即：

• 当对记录进行操作时，即便是通过主键扫描，也可能对二级索引进行加锁
• 当对记录进行操作时，即便是通过二级索引扫描，也可能对主键进行加锁

这类场景的加锁，通常都是会存在隐式锁。

主键操作时二级索引上的隐式锁

在下面的测试中，我们先主键 id = 8的记录进行删除操作，然后通过系统表data_locks观察该事务是否持有二级索引相关的锁；而后，在另一个事务中，通过二级索引（nick = 'Henry'）对该记录进行操作（共享读），而后再重新观察前面事务的锁状态。

在下面的测试可以观察到，在Session B没有开始前；在 Session A的DELETE语句是观测不到二级索引上的锁的；但当Session B尝试去锁定二级索引上的入口时，再次观察Session A上的锁信息，就可以看到，在Session A没有任何操作的情况下，多出了一个额外的、持有的二级索引上的锁，该锁原本是一个“隐式锁”，在发生锁竞争后，转化为一个“显式锁”。即便是在Session B因为等待操作或结束了，Session A持有的已经转化的“显式锁”也不会再回退了。详细测试如下。

准备数据

DROP TABLE IF exists t1;
 CREATE TABLE `t1` (
  `id` int unsigned,
  `nick` varchar(32),
  `age` int,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_n` (`nick`)
);

mysql> INSERT INTO t1 VALUES (1,"Alice",12);
mysql> INSERT INTO t1 VALUES (8,"Henry",27);
mysql> INSERT INTO t1 VALUES (16,"Peter",15);
mysql> show variables like '%iso%';
+-----------------------+----------------+
| Variable_name         | Value          |
+-----------------------+----------------+
| transaction_isolation | READ-COMMITTED |
+-----------------------+----------------+

构建隐式锁

mysql> START TRANSACTION;
mysql> DELETE FROM t1 WHERE id = 8;

mysql> SELECT
    ->     ENGINE_TRANSACTION_ID AS TRX_ID,
    ->     INDEX_NAME,LOCK_TYPE,
    ->     LOCK_MODE, LOCK_STATUS,
    ->     LOCK_DATA
    ->   FROM performance_schema.data_locks;
+--------+------------+-----------+---------------+-------------+-----------+
| TRX_ID | INDEX_NAME | LOCK_TYPE | LOCK_MODE     | LOCK_STATUS | LOCK_DATA |
+--------+------------+-----------+---------------+-------------+-----------+
|  10317 | NULL       | TABLE     | IX            | GRANTED     | NULL      |
|  10317 | PRIMARY    | RECORD    | X,REC_NOT_GAP | GRANTED     | 8         |
+--------+------------+-----------+---------------+-------------+-----------+

隐式锁转换为显式锁

继续上述两个Sessions的操作：

mysql> START TRANSACTION;
mysql> SELECT * FROM t1 WHERE nick = 'Henry' FOR SHARE;
( Waiting )

...(Query Locks From performance_schema.data_locks like above)...
+-----------------+------------+-----------+---------------+-------------+------------+
| TRX_ID          | INDEX_NAME | LOCK_TYPE | LOCK_MODE     | LOCK_STATUS | LOCK_DATA  |
+-----------------+------------+-----------+---------------+-------------+------------+
|           10317 | NULL       | TABLE     | IX            | GRANTED     | NULL       |
| 421929568337920 | NULL       | TABLE     | IS            | GRANTED     | NULL       |
|           10317 | uk_n       | RECORD    | X,REC_NOT_GAP | GRANTED     | 'Henry', 8 |
| 421929568337920 | uk_n       | RECORD    | S,REC_NOT_GAP | WAITING     | 'Henry', 8 |
|           10317 | PRIMARY    | RECORD    | X,REC_NOT_GAP | GRANTED     | 8          |
+-----------------+------------+-----------+---------------+-------------+------------+

(... Abort last statement...)
ERROR 1205 (HY000): Lock wait timeout exceeded; 
try restarting transaction

...(Query Locks From performance_schema.data_locks like above)...
+--------+------------+-----------+---------------+-------------+------------+
| TRX_ID | INDEX_NAME | LOCK_TYPE | LOCK_MODE     | LOCK_STATUS | LOCK_DATA  |
+--------+------------+-----------+---------------+-------------+------------+
|  10317 | NULL       | TABLE     | IX            | GRANTED     | NULL       |
|  10321 | NULL       | TABLE     | IS            | GRANTED     | NULL       |
|  10317 | uk_n       | RECORD    | X,REC_NOT_GAP | GRANTED     | 'Henry', 8 |
|  10317 | PRIMARY    | RECORD    | X,REC_NOT_GAP | GRANTED     | 8          |
+--------+------------+-----------+---------------+-------------+------------+

最后

一些理解

“隐式锁”可以理解为，在某些条件下，这里一定是存在“锁”的，所以，既然一定是存在的，并且这类场景可能还比较广泛，那么为了节省存储空间与操作，就省略了此类“锁”的表示。例如，通常，如果事务写入了一条数据，那么该事务一定是持有该数据的排它锁的。

但，当真的有其他事务也尝试去获取该“隐式锁”的时候，那么为了便于进行锁检测与管理，则会重新将该锁表示出来。并且，也不再有必要重新转化为隐式锁。

所以，如果有人问，你是否可以把当前数据库的所有的锁情况，都打印或记录下来，这是做不到的，也是没有必要的。事实上，“隐式锁”是广泛存在的，但因为通常并没有那么锁竞争，这些“隐式锁”也就一直不会被表示出来。

一块拼图

通常，隐式锁是可以被忽略的，如上述示例，这可能是一个没有任何竞争的锁。但，当出现对应的锁竞争时，则会变得可见。一般地，是可以不用关注隐式锁的，但，如果希望能够对 InnoDB 锁有非常系统的了解，这也是一块重要的“拼图”。