在项目上线时，你是否还在手动打包上传服务器，执行命令进行部署项目呢？这种方式一旦操作失误，就会降低线上环境的可靠性。今天给大家分享一下如何基于 Jenkins + Docker 从 GIT 上自动获取代码进行自动化构建部署 SpringBoot 项目。

## Jenkins 简介

Jenkins是一个开源的自动化服务器，由Java编写，主要用于持续集成（CI）和持续交付/部署（CD）的自动化工作流。它通过插件生态系统扩展功能，支持与各种工具集成，如版本控制系统（Git、SVN）、构建工具（Maven、Gradle）、测试框架（JUnit、TestNG）和部署工具（Docker、Kubernetes）等。Jenkins旨在通过自动化构建、测试和部署流程，提高开发效率，减少人为错误，缩短交付周期。

## Jenkins 安装

这里采用 Docker 的形式来安装，拉取镜像的命令如下：

```
sh

docker pull jenkins/jenkins:lts
```

![image.png](https://blog.liushigong.cn/static/img/6a87d7066f9da72a8937327259e7d4d3.image.webp)

镜像拉取完成后，创建容器运行，其默认端口是8080，容易与其他端口冲突，所以映射为 8880

```
sh

docker run -p 8880:8080 -p 5000:5000 --name jenkins \
    -u root \
    -v /opt/docker/jenkins:/var/jenkins_home \
    -d jenkins/jenkins:lts
```

![image.png](https://blog.liushigong.cn/static/img/2d22976400cb0d8d26f4019b34b685fb.image.webp)

到此 jenkins 容器已启动完成

![image.png](https://blog.liushigong.cn/static/img/75c38dbd9e195153e52ef31a3d997e0e.image.webp)

## Jenkins 初始化

接下来我们将访问 Jenkins 界面，访问地址是 <http://IP:8880/> ,初次登录需要输入管理员密码才可以使用

![image.png](https://blog.liushigong.cn/static/img/5300854355e6c0a3b35f11d50d07e870.image.webp)

通过 `docker logs jenkins` 查看启动日志，密码会在控制台输出

![image.png](https://blog.liushigong.cn/static/img/ae189ac3b6156e9002bebef919dc74a3.image.webp)

当密码验证成功后，跳转到插件安装的页面，这里选择 `安装推荐的插件`

![image.png](https://blog.liushigong.cn/static/img/6557139c40654d294228a383145e9021.image.webp)

创建第一个管理员账户

![image.png](https://blog.liushigong.cn/static/img/4f101d14cdd60b1e908ff6eb14452f5f.image.webp)

![image.png](https://blog.liushigong.cn/static/img/0fb7dcc19af4c1ea0925ac8ec16268cf.image.webp)

![image.png](https://blog.liushigong.cn/static/img/3f135e87aa0f11de26dfe29cb1e5646b.image.webp)

## Jenkins 配置

### 插件安装

点击右上角的系统管理，选择插件管理，开始进行插件的安装

![image.png](https://blog.liushigong.cn/static/img/9ebc5447bb9a054d2a5c3cb9a0096fdc.image.webp)

安装 `Publish Over SSH` 插件，用于访问远程主机并执行命令。

![image.png](https://blog.liushigong.cn/static/img/40893bb22051b73ab6cdf0f9c617a63c.image.webp)

### SSH 配置

找到 系统管理 -> 系统配置

![image.png](https://blog.liushigong.cn/static/img/10e844c7ed913666747dcadea2a7d4d9.image.webp)

找到 SSH Servers 部分，填写要部署连接的服务器信息，需要注意的是必须装上 `Publish Over SSH` 插件才会有此功能项

![image.png](https://blog.liushigong.cn/static/img/21f3a3cc6b48273a13db3cda6bd49efa.image.webp)

点击高级，勾选上 `Use password authentication, or use a different key` 后，配置服务器的密码，配置完成后，点击下方 `Test Configuration` 测试连接是否成功

![image.png](https://blog.liushigong.cn/static/img/9d081c106cf6ff30d05dddf0657cd0b6.image.webp)

### Maven 配置

找到 系统管理 -> 全局工具配置

![image.png](https://blog.liushigong.cn/static/img/426b7a7dae1db084fe10b996e2316a5f.image.webp)

首先配置 Maven，滑动到最下方，找到 Maven 安装，新增 Maven，填写个名字，点击保存

![image.png](https://blog.liushigong.cn/static/img/ee2ee914661a117c1b9c88c0ff0f3e26.image.webp)

到这 Jenkins 就算配置完成了，接下来我们看下如何自动化部署 SpringBoot 项目。

## 一键部署 SpringBoot 项目

### 编写 Dcokerfile

在项目的根目录下，创建 docker 文件夹，编写 Dockerfile，内容如下，根据实际服务配置编写即可

```
sh

FROM openjdk:17-jdk

RUN rm -rf /etc/localtime &&\
    ln -s /usr/share/zoneinfo/Asia/Shanghai /etc/localtime &&\
    echo "Asia/Shanghai" > /etc/timezone

COPY *.jar /data/

EXPOSE 9527

WORKDIR /data

ENV JAVA_OPTS="-Xms128m -Xmx128m"
ENV JAR_PATH="/data"
ENV EXAM_ENV="prod"
ENV LOGGING_PATH="/data/logs"

ENTRYPOINT java ${JAVA_OPTS} \
    -Dlogging.path=${LOGGING_PATH} \
    -DSpring.profiles.active=${EXAM_ENV} \
    -Dfile.encoding=UTF-8 \
    -XX:NativeMemoryTracking=detail  \
    -jar ${JAR_PATH}/*.jar
```

### 新建任务

接下来我们通过 Jenkins 来创建任务实现 SpringBoot 项目的自动化部署，回到首页，点击新建任务

![image.png](https://blog.liushigong.cn/static/img/9f6e81f795064a8bdd4974cbce10d030.image.webp)

填写任务的名称，一般就是服务名称，选择 `构建一个自由风格的软件项目`，点击确定

![image.png](https://blog.liushigong.cn/static/img/47544984083c737d517e549b80a8ce1a.image.webp)

#### 配置选项参数

通过选项参数，可以让脚本动态获取到选项参数的值，让脚本变得更加通用，此处配置2个选项参数

* var\_project\_name 项目名称
* var\_app\_docker\_path 软件工作目录

![image.png](https://blog.liushigong.cn/static/img/52a3d1757aec33100f492bff8c87055f.image.webp)

#### 配置GIT仓库

紧接着在源码管理中，配置 Git 仓库地址，注意仓库地址必须是公共的

![image.png](https://blog.liushigong.cn/static/img/612482aed0a702203e3bdd6d15e847a1.image.webp)

#### 添加Maven构建

点击 `Build Steps` -> `增加构建步骤` -> `调用顶层 Maven 目标`

![image.png](https://blog.liushigong.cn/static/img/03f97ff8200ef7d79e8f2c75d9bd88cd.image.webp)

选择之前配置的 `Maven 3.9.11`，添加目标也就是构建命令 `clean install`，点击高级，配置上 POM 文件目录 `${workspace}/pom.xml`

再次添加构建步骤，目标 `clean package`，POM 目录为 `${WORKSPACE}/pom.xml`，点击 Save 保存

![image.png](https://blog.liushigong.cn/static/img/8e744a402d4643cfb67e50bce5f6539d.image.webp)

注意

此处我得目录结构为

* echo-im
* echo-im-web
* echo-im-common
* echo-im-framework
* echop-im-websocket

echo-im 即为根目录，是pom类型，当执行 `clean install` 时，其子模块会自动构建，需要根据实际目录地址选择 pom.xml 文件

#### 选择服务器与部署目录

此处选择之前插件中配置的服务器别名，点击高级，勾选 `Verbose output in console`，构建开始后会在控制台输出详细的日志

接下来开始添加需要上传的文件

* Source files 要上传的源文件
* Remove prefix 删除源文件中的目录前缀，相当于只保留源文件目录中，如果不配置，则会跟源文件目录一起上传
* Remote directory 上传源文件存放在服务器中的目录

此处选择根目录下 docker/Dockerfile 文件进行上传，在 build 时会用到

注意

此处的项目路径是内置 Mavan 编译路径，实际为 `/var/jenkins_home/workspace/echo-im`，可通过相对路径获取 echo-im 项目下的编译内容

![image.png](https://blog.liushigong.cn/static/img/243ae88b701deaf590ea6bbe307cebbb.image.webp)

配置要上传的jar包，同时也要去除下路径前缀，只保留jar包上传即可

![image.png](https://blog.liushigong.cn/static/img/121b3c35a9e6953374d05a11536375fa.image.webp)

动态的执行脚本如下，根据不同的项目路径会自动进行构建运行，还有一种方式可以将脚本放到 docker 目录下，例如是 run.sh ，与 Dockerfile 一起上传，当上传jar包后执行 `sh run.sh`

```
sh

#!/bin/bash
echo "=================================================================="
echo "                          开始部署流程"
echo "=================================================================="
echo "当前时间: $(date)"
echo "部署名称: ${var_project_name}"

#获得变量
var_images_id=`docker images|grep -i ${var_project_name}|awk '{print $3}'`
var_ps_id=`docker ps -a|grep -i ${var_project_name}|awk '{print $1}'`
echo "${var_project_name} docker images ID:${var_images_id}"
echo "${var_project_name} docker ps ID:${var_ps_id}"

#结束镜像任务
if [ -n "$var_ps_id" ]; then
   docker rm -f ${var_ps_id}
   echo "结束镜像:${var_project_name},ID:${var_images_id}"
fi

#删除历史镜像
if [ -n "$var_images_id" ]; then
    docker rmi -f ${var_images_id}
    echo "删除镜像:${var_project_name} ID:${var_images_id}"
fi

#切换工作目录
cd /${var_app_docker_path}/${var_project_name}
echo "当前目录:$(cd "$(dirname "$0")";pwd)"

# 添加权限
chmod 721 Dockerfile
echo "Dockerfile 添加权限"

#开始构件镜像
docker build -t ${var_project_name} .
echo "构建镜像:${var_project_name}"

#执行镜像
docker run -it -d -p 9527:9527 -p 8101:8101 --name ${var_project_name}  --link redis:7.2.4 -e TZ="Asia/Shanghai" -v /opt/docker/${var_project_name}/logs:/data/logs -v /opt/docker/nginx/html:/data/upload ${var_project_name}
echo "${var_project_name} is running!"
echo "=================================================================="
echo "                          部署流程结束"
echo "=================================================================="
```

到此，任务构建的准备工作就完成了，服务中的整体效果如下

![image.png](https://blog.liushigong.cn/static/img/d09cac56a6f952d200d3ee697c001698.image.webp)

### 开始部署

开始构建，确认填写的选项参数，点击 build

![image.png](https://blog.liushigong.cn/static/img/04648c32a27c153997215f136a574d15.image.webp)

查看控制台输出，如果运行的过程中存在问题根据控制台的输出信息进行调试即可

![image.png](https://blog.liushigong.cn/static/img/dd30cb3b8b6666fe3ea3260854368047.image.webp)

运维部署 - 基于 Jenkins + Docker 一键打包部署 SpringBoot 项目

很多小伙伴会问，为什么要准备面试前的自我复盘？这个问题很实际，自我的复盘有助于深入了解自身对职业发展，同时可以系统性地提升面试成功率。大多数人可能已经有一定面试经验，但通过复盘可以更结构化地准备，面试前的系统复盘是提升竞争力的关键。

## 面试前的复盘

作为高级开发者，往往需要的不是基础技术点的复习，而是深度和广度的平衡，以及项目经验的精准表达。大多数人潜在焦虑可能是：**如何在竞争中突出自己的优势**

### 对自身的复盘

首先要结合自身的定位进行一个复盘，需要系统性评估自己的市场竞争力和发展路径，一般会考虑以下几种情况：年龄、工作年限、薪资、技术体系、职业规划等等

其实复盘的本质就是 “如何在薪资期望、年龄压力、技术深度之间找到平衡点”，这比纯技术复盘更复杂，涉及市场定位和职业策略。对于大龄程序员换句话说，我该继续走技术专家路线，还是向架构师/管理转型？当前薪资要求是否合理？

#### 年龄与职业阶段对标（现实定位）

![deepseek_mermaid_20250605_28bcab.png](https://blog.liushigong.cn/static/img/44c76160a32f6273e1dd26b1b3a2350d.deepseek_mermaid_20250605_28bcab.webp)

复盘重点：

* 技术深度匹配度：35岁+需重点展示架构设计能力（如主导过百万级QPS系统）
* 管理潜力储备：准备技术管理双通道案例（如带队完成DevOps落地）
* 年龄优势转化：突出经验带来的风险预判能力（如规避过重大技术债务）

#### 工作年限价值挖掘（能力贴现）

| 年限 | 必备价值点 | 面试展现重点 |
| --- | --- | --- |
| 5-7年 | 复杂系统优化能力 | 性能提升量化指标（如GC耗时降80%） |
| 8-10年 | 技术决策ROI分析能力 | 技术选型对比报告（Kafka vs RocketMQ） |
| 10年+ | 技术战略规划能力 | 架构演进路线图（单体→微服务→云原生） |

这个时候在突出自己的亮点是需要额外的注意：

❌ “我做了XX年CRUD” → ✅ “近3年主导完成了支付系统架构升级，TPS从2k提升至12万”

#### 职业规划黄金三问（发展路径设计）

**技术深度规划**

例如：未来3年深耕云原生技术栈，计划考取CKA认证并落地Service Mesh，5年内具备百万级并发系统架构能力

**管理能力规划**

| 能力维度 | 当前水平 | 目标举措 |
| --- | --- | --- |
| 技术决策 | 模块级决策 | 学习TOGAF企业架构框架 |
| 团队培养 | 指导3人小组 | 建立新人培养SOP机制 |

**行业影响力规划**

* 技术输出：维护技术博客（年均20+原创）
* 社区参与：成为Apache项目Contributor
* 专利储备：申请2项分布式技术相关专利

### 掌握技术栈的复盘

对自身技术栈要有一个清晰的认知，可以罗列出主流技术栈，自我总结每项技术栈的掌握程度，对还没有掌握的知识体系进行学习补充。

**技术栈三维检测表**

重点准备「能说清原理但写不出代码」的技术点，例如：Spring循环依赖、Redis分布式锁、JVM FullGC优化等等

**源码级追问自测**

可以结合 `AI` 充当面试官，深入技术栈体系进行提问，做到能 **描述核心类结构**、**关键算法逻辑**、**指出源码缺陷/改进** 等程度

**硬伤转化策略（问题破局）**

| 潜在质疑点 | 转化策略 | 证据准备 |
| --- | --- | --- |
| 技术迭代能力 | 展示新技术落地案例 | 主导JDK17升级实践报告 |
| 薪资成本高 | 突出效能提升ROI | 自动化测试节省人天数据 |
| 职业激情衰退 | 开源项目贡献证明 | GitHub年度Contributor统计 |

### 项目经验的复盘

工作除了赚钱以后，并不是没有意义的，我们的复盘就是需要对工作中的 **价值提炼**

将工作中遇到的难点、生产问题与技术方案选型与实现进行总结与分析，将别人的知识转换成自己的，结合简历上项目的经验进行优化，尤其是 **量化指标** 的描述

**项目复盘STAR-R升级模型**

| 维度 | 关键问题 | 复盘重点 |
| --- | --- | --- |
| Situation | 项目背景中哪些是面试官关心的痛点？ | 用行业术语重构背景描述 |
| Task | 你的职责是否体现技术深度？ | 将"参与"改为"主导/设计" |
| Action | 技术方案是否有理论支撑？ | 关联CAP定理等原理 |
| Result | 数据是否量化到业务价值？ | "TPS↑200%" → "GMV↑5%" |
| Review | 如果重做会如何改进？ | 引入新技术方案对比 |

#### 案例转化

**原描述：**

“用Redis做了缓存优化”

**升级后：**

“针对商品查询接口99线>1s问题（痛点），主导设计多级缓存架构（LazyCache+Redis）（深度），
基于布隆过滤器解决缓存穿透（原理），查询性能提升15倍（量化），节省40%数据库成本（业务价值）”

### 总结

* 技术复盘：避免陷入“面经题海”，每天深挖1个核心原理比刷20题更重要
* 项目复盘：忌用“我们”模糊个人贡献，用“我设计/我推动/我实施”强化主动性
* 沟通陷阱：当被问“还有什么问题？”时，禁用“没问题”，可问：

  ```
  “团队在技术债管理上的实践？”
    “这个岗位解决的最核心技术挑战是什么？”
  ```

最后黄金法则：所有技术陈述遵循「三线穿透」原则：业务场景→技术实现→底层原理，

通过系统化复盘，将零散经验转化为结构化认知体系，面试官感知到的不仅是技术能力，更是清晰的思维框架和成长潜力。

面试技巧 - 面试前对自己的复盘

数据库 - 深度探索 Mysql 的 binlog、redo log、undo log

幻读（phantom read），是指在一个事务中前后两次相同的查询产生不同的结果集，后一次查询看到了前一次查询没有看到的记录行。

MySQL InnoDB默认的事务隔离级别是可重复读，可重复读的要旨在于同一数据行记录在一个事务内无论何时查询结果都是一样的。

从定义可以知道，可重复读解决的问题和幻读问题有实质性的区别，一个针对同一行记录，一个说的是数据行数，那么，MySQL又是怎么解决幻读问题的呢，今天就来一探究竟

## Mysql 如何解决幻读

首先，我们的前提是在MySQL数据库内，使用的引擎是InnoDB引擎，且事务的隔离级别是可重复读。

前面文章有讲过，MySQL InnoDB 依靠 MVCC 实现事务隔离级别。MVCC 又称多版本并发控制，它的全称是 Multi-Version Concurrency Control，直白说就是在同一时刻同一条记录在系统中可以存在多个版本。

### 快照读和当前读

#### 当前读

MySQL的MVCC决定了同一数据行可能会同时存在多个版本的情况，当前读表示读取的记录是最新版本的，且读取的时候，如果有其他并发事务要修改同一数据行，当前事务会通过加锁让其他事务阻塞等待。

比如`select lock in share mode`(共享锁)、`select for update`、`update`、`insert` 、`delete`(排他锁)等操作都是一种当前读，这些操作会对读取的记录进行加锁。

#### 快照读

表示不加锁的非阻塞读，像普通的 select 操作就是快照读。快照读的实现基于 MVCC，它实现了事务内任何时刻读取的数据都是历史某个版本的数据，不一定是当前时刻最新的数据。

MVCC这种实现方式也是一种锁的变种，但它避开了加锁操作，大大降低系统的开销，从而提高系统的性能。
需要特别注意的是，快照读在MySQL的串行隔离级别下会上升为当前读，即使是 select 操作也会加锁。

### 快照读如何解决幻读？

假如我们有一张账户余额表bank\_balance，其结构如下，里面的初始数据行有9行。

```
sql

CREATE TABLE `bank_balance`
(
    `id`        int         NOT NULL AUTO_INCREMENT,
    `user_name` varchar(45) NOT NULL COMMENT '用户名',
    `balance`   int         NOT NULL DEFAULT '0' COMMENT '余额，单位：人民币分，比如100表示人民币1元，默认是0',
    `wealth`    tinyint     NOT NULL DEFAULT '0' COMMENT '富有程度，0：贫穷，1：富有',
    PRIMARY KEY (`id`),
    UNIQUE KEY `idx_bank_balance_user_name` (`user_name`)
) ENGINE = InnoDB
  AUTO_INCREMENT = 10
  DEFAULT CHARSET = utf8mb4
  COLLATE = utf8mb4_0900_ai_ci;
```

初始数据行：

```
sql

INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (1, '小埃', 0, 0);
INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (2, '小克', 300000000, 0);
INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (3, 'Tom', 500, 0);
INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (4, 'Eric', 100, 0);
INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (5, 'AI', 0, 0);
INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (6, 'Alex', 100, 0);
INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (7, 'Max', 100, 0);
INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (8, 'Mike', 100, 0);
INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (9, 'Lyn', 200, 0);

mysql> select *from bank_balance;
+----+-----------+-----------+--------+
| id | user_name | balance   | wealth |
+----+-----------+-----------+--------+
|  1 | 小埃      |         0 |      0 |
|  2 | 小克      | 300000000 |      0 |
|  3 | Tom       |       500 |      0 |
|  4 | Eric      |       100 |      0 |
|  5 | AI        |         0 |      0 |
|  6 | Alex      |       100 |      0 |
|  7 | Max       |       100 |      0 |
|  8 | Mike      |       100 |      0 |
|  9 | Lyn       |       200 |      0 |
+----+-----------+-----------+--------+
9 rows in set (0.01 sec)
```

假设现在有两个事务，事务A和事务B，同时操作这张余额表，两个事务的操作时间线如下：

![image.png](https://blog.liushigong.cn/static/img/89e0f36d8f87f4613e5385f167aa1167.image.webp)

事务A有两次查询，分别在③和⑤，都是采用相同的SQL语句：`select * from bank_balance where balance > 0`（普通select是一种快照读），目的都是查询所有balance > 0的rows。

* ①和②：开启事务。
* ③：事务A通过 `select * from where balance > 0` 得到的结果是7 Rows，如下：

![image.png](https://blog.liushigong.cn/static/img/558d0bac10236c1f5fb02425b6d54221.image.webp)

* ④：事务B插入一行记录 `INSERT INTO bank_balance (id, user_name, balance, wealth) VALUES (10, 'Loop', 100, 0);`。
* ⑤：事务A通过 `select * from bank_balance where balance>0` 再次查询得到的结果，同样还是7 Rows。
* ⑥和⑦：提交事务。

为什么第⑤处查询时结果还是7 Rows呢？

大家应该都还记得MVCC，事务A在第③处就会生成一个 ReadView 记录当前的活跃事务，事务B就在活跃事务范围内，在第⑤处事务B insert的记录隐藏列事务id不满足事务A读取，事务A会顺着undo log的版本链查到满足的记录为止（当然，该记录是事务B新增的，顺着版本链找最终只能找到null，所以该记录不返回）。

### 当前读如何解决幻读？

同样是上面的表和查询时间线，只是查询语句换成了当前读的查询 `select * from bank_balance where balance > 0 for update`，假设没有锁，那么就会发生幻读现象，如下：

![image.png](https://blog.liushigong.cn/static/img/093347a390bf657bb05d1426d48f65b0.image.webp)

重复快照读的1-4步，在 insert完数据以后，这个时候事务A通过 `select * from bank_balance where balance > 0 for update` 再次查询得到的结果是8 Rows，如下

![image.png](https://blog.liushigong.cn/static/img/90e96204d19faf7ade8a7439cf409130.image.webp)

第③和第⑤同样是查询bank\_balance > 0 的记录但得到的结果却不一样，这就是幻读现象（以上只是预估会产生的情况，实操中不会出现上述情况，因为其用了以下的解决方案，请继续阅读）。

为了解决幻读问题，MySQL InnoDB 引擎引入了 `next-key lock`，其等同于 **间隙锁+记录锁** 的组合。

记录锁，顾名思义，就是给数据行加的锁，那何为间隙锁？

假设，bank\_balance表中只存在余额balance>0且主键id 为4和6的记录，那么当一个事务使用 `select * from where balance>0 for update` 查询时，其他事务就无法插入 id = 5的记录，就像是事务A把(4,6)这个范围锁住了，这就是间隙锁。

如果再把id=4和6的记录也同时一起锁了，合起来变成一个闭区间[4, 6]，那么整个区间锁也叫 `next-key lock`。

还是以上的例子，事务B在事务A查询后进行insert操作：

![image.png](https://blog.liushigong.cn/static/img/277f37bf0f678750eb67add428777880.image.webp)

事务 A 在③处执行了 `select * from bank_balance where balance > 0 for update` 这条锁定读语句后，就会 **把整个表所有记录锁上(因为balance字段无索引)**，并根据主键id和表记录形成多个 `next-key lock`，分别是：(-∞, 1]、(1, 2]、(2, 3]、(3, 4]、(4, 5]、(5, 6]、(6, 7]、(7, 8]、(8, 9]、(9, +∞]，每个 `next-key lock` 都是前开后闭区间。

然后，事务 B 在④处执行插入语句，发现id=10被事务 A 加了 `next-key lock`，于是事务 B 会生成一个写锁，开始阻塞等待，**直到事务 A 提交了事务才会执行**。这就避免了上述所说的幻读问题。

以上的例子比较特殊，如果我们的表中只有两条记录，分别是(4, 'Eric', 100,0)、(10, 'Loop', 100,0)，那么当我们执行 `select *from bank_balance where id > 8 for update` 时，就只会形成两个 `next-key lock` ，它就是(4, 10]，(10, +∞]，如果我们执行 `insert into bank_balance values(5,'MALL',100,0)` 将会被阻塞，但是我们执行 `insert into bank_balance values(2,'MALL',100,0)` 就不会被阻塞，因为id=2没有被锁住。

特别说明一下，`next-key lock` 基于记录形成，不是基于查询条件形成，有些同学问到上文的例子中两个`next-key lock` 为什么不是(8, 10]、(10, +∞]，就是这个原因。

## 可重复读完全解决幻读了吗？

MySQL InnoDB 默认的可重复读隔离级别加上 `next-key lock` 一定程度上解决了幻读问题，但依然存在特殊的情况下产生幻读问题。

### 第一种情况

先启动的事务A使用快照读，后启动的事务B插入新的数据行并提交，然后事务A再更新，其后A的查询都能查事务B新增的数据行。

![image.png](https://blog.liushigong.cn/static/img/65da4b57d3780a0259ed7a66f5c244f5.image.webp)

* ③：表中没有id=5的记录行，所以事务A查询的结果是0Rows。
* ④-⑥：事务B启动，并插入一条id=5的记录，后提交事务。⑦：事务A更新id=5的记录。
* ⑧：事务A查询id=5的记录，结果Rows=1，产生了幻读。按MVCC的原理，第⑧处事务A查询结果不应该返回id=5的记录，但因为有update在先，所以该记录背查询了出来。

**快照读不会加锁，导致事务B可以 `insert` 成功，而 `update` 语句又是当前读，能够更新id=5的数据，所以，当执行⑧时，快照读也就能够查询出来id=5的记录了。**

### 第二种情况

如果事务一开始没有使用当前读，当其他事务插入数据并提交后再使用当前读就会发生幻读现象。

![image.png](https://blog.liushigong.cn/static/img/d6e75000bd54b2af940023815396eb9e.image.webp)

* ③：表中没有id=5的记录行，所以事务A采用快照读方式查询的结果是0Rows。
* ④-⑥：事务B启动，并插入一条id=5的记录，后提交事务。
* ⑦：事务A采用当前读的方式查询id=5的行，结果Rows为1，产生了幻读。

这种情况是因为快照读不生成 `next-key lock` 导致，其他事务可以插入本事务查询范围内的记录行，所以，当其他事务插入数据后再执行当前读，就能查到新的记录，从而产生幻读问题。

一般在开发过程中建议开启一个事务时尽快采用 `for update` 的查询方式，以生成 `next-key lock`，避免幻读问题。

本质

未解决幻读的本质原因，就是在当前事务中使用了 **当前读** 读取了其他事务提交的数据，那数据就会被加载到当前 ReadView 中，后续事务操作都能从快照中读取数据了。

## 总结

mysql 中数据读取分为 **快照读** 与 **当前读**，快照读通过 MVCC 中 undo log + ReadView 解决幻读；当前读是在 MVCC 的基础上，结合临键锁 `next-key lock` 解决幻读，临键锁是间隙锁与记录锁的组合，其中有唯一性索引的会添加记录锁，如果没有索引的会添加 `next-key lock`，结合间隙锁保证锁定索引中的记录及其前面的间隙，从而防止其他事务在查询范围内的间隙中插入新记录，有效避免幻读‌。

数据库 - Mysql 可重复读如何解决幻读？

工作了这么长时间，总是觉得缺点什么，今天想明白了，需要给自己出一本SQL使用手册，对 SQL 的使用与解析进行一次全面讲解，以及总结在实战中常操作的 **复制表、临时表、多表更新** 等刷数据操作。

数据库操作

CRUD

where(筛选)

and 和 or（与和或）

between（范文查找）

disinct（去重关键字）

update（更新修改）

delete（删除）

like（模糊匹配）

order by（排序）

group by（分组）

with rollup（分组后再统计）

having（分组筛选）

union 和 union all（组合查询）

join（连接查询）

inner join（内连接）

left join（左连接）

right join（右连接）

子查询

in 和 not in（多项匹配）

exists 和 not exists （是否返回结果集）

复制表

临时表

多表更新