Singerw's Repository
Singerw
2021-09-25

SpringBoot锁 -Mybatis

# SpringBoot锁 -Mybatis

数据库加锁，是为了处理并发问题，在并发下保证数据一致性。

虽然我们在发开的过程中，没有使用锁的情况下，我们的程序也可以正常的执行，那是因为数据库帮我们隐式的添加了锁，按照使用方式可以讲锁分为：悲观锁和乐观锁；按照粒度可分为：全局锁，表锁和行锁，并在出现死锁后如何解决。

# 1、乐观锁和悲观锁的适用场景：

悲观锁：比较适合写入操作比较频繁的场景，如果出现大量的读取操作，每次读取的时候都会进行加锁，这样会增加大量的锁的开销，降低了系统的吞吐量。

乐观锁：比较适合读取操作比较频繁的场景，如果出现大量的写入操作，数据发生冲突的可能性就会增大，为了保证数据的一致性，应用层需要不断的重新获取数据，这样会增加大量的查询操作，降低了系统的吞吐量。

总结：两种所各有优缺点，频繁读取使用乐观锁，频繁写入使用悲观锁。

# 2、悲观锁与其原理

悲观锁：

悲观锁则认为拿到的数据一定会被别人修改，为了防止被人修改，当我一拿到数据，我就对它进行加锁，这样别人就无法获得我的数据，只有等我操作完成释放锁后，后面的人才能获得我的数据。悲观锁的实现直接在语句后面加for update即可.

就是独占锁，不管读写都上锁了。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

# 3、乐观锁与其原理

乐观锁：

每次获取数据的时候，都不会担心数据被修改，所以每次获取数据的时候都不会进行加锁，由于数据没有进行加锁，期间该数据可以被其他线程进行读写操作。

乐观锁的原理：

乐观锁，大多是基于数据版本 ( Version)记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来 实现（表中添加一个字段 version）。 读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数 版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

乐观锁的实现：

在数据库和实体类中添加一个int型的version字段，生成getter和setter方法。

# 4、悲观锁实现

# 步骤一：mapper.xml文件

需要使用select for update，即select * from A Where id=1 for update;

在mapper.xml中sql查询语句中加入for update

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.singerw.dao.ArticleMapper">
    
    <sql id="Base_Column_List">
        <!--@mbg.generated-->
        a_id, article_title, article_content, head_image, article_author, type_number, pageviews,
        create_time, is_state, version
    </sql>

    <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
        <!--@mbg.generated-->
        select
        <include refid="Base_Column_List"/>
        from article
        where a_id = #{aId,jdbcType=INTEGER} for update
    </select>
    
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 步骤二：Service接口

public interface ArticleService {

    void testUptateLock1(Integer aId);

    void testUptateLock2(Integer aId);

}
1
2
3
4
5
6
7

# 步骤三：service实现类

@Service
public class ArticleServiceImpl implements ArticleService {

    @Resource
    private ArticleMapper articleMapper;

    @Override
    @Transactional
    public void testUptateLock1(Integer aId) {
        // 1 先做查询
        Article article = articleMapper.selectByPrimaryKey(aId);

        // 2 修改对象的属性值
        article.setArticleTitle("悲观锁_lock测试的Title_1");

        // 模拟其他的业务
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 3 调用修改的方法
        int result = articleMapper.updateByPrimaryKeySelective(article);

        // 自定义空指针异常
        String str = null;
        System.out.println(str.length());
    }

    @Override
    @Transactional
    public void testUptateLock2(Integer aId) {
        // 1 先做查询
        Article article = articleMapper.selectByPrimaryKey(aId);

        // 2 修改对象的属性值
        article.setArticleTitle("悲观锁_lock测试的Title_2");

        // 3 调用修改的方法
        int result = articleMapper.updateByPrimaryKeySelective(article);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

这里在testUptateLock1方法中模拟了一个线程休眠来代替业务的执行时间，在10秒内，我们再尝试去控制器调用testUptateLock2，等待10秒的时间时为了后续测试方便能发现测试结果。

# 步骤四：控制器

@RestController
@RequestMapping("/api")
public class ArticleController {

    @Autowired
    private ArticleService articleService;

    @GetMapping("/updateLock01/{aId}")
    public String updateLock01(@PathVariable("aId") Integer aId){
        articleService.testUptateLock1(aId);
        return "updateLock01 OK!";
    }

    @GetMapping("/updateLock02/{aId}")
    public String updateLock02(@PathVariable("aId") Integer aId){
        articleService.testUptateLock2(aId);
        return "updateLock02 OK!";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 步骤五：访问进行测试

首先访问控制器的updateLock01的/updateLock01/{aId},访问的时候，需求等待十秒才能执行结束，

同时，我们再控制器的updateLock01执行等待的10秒内去访问updateLock02的/updateLock02/{aId},

而updateLock02需求等待updateLock01执行结束后才会执行。

# 总结

在SQL写了一个查询 : … for update，加了这个后，只有当控制器的updateLock01执行结束后updateLock02才有机会执行。这是典型的悲观锁的具体实现。

# 5、乐观锁实现

# 步骤一：添加列和完善实体类

数据库表中加一个字段 version =>int 初始值为0,实体类中也有一个private int version

model：Article.java

@ApiModel(value = "article")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Article implements Serializable {
    /**
     * 文章ID
     */
    @ApiModelProperty(value = "文章ID")
    private Integer aId;

    ...

    /**
     * 乐观锁
     */
    @ApiModelProperty(value = "乐观锁")
    private Integer version;

    private static final long serialVersionUID = 1L;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 步骤二：mapper.xml

数据库sql语句层面，我们每次提交数据(update) 的时候，我们需要将版本号更新；原有版本号上+1; 修改语句的条件也要加上…. And version =#{version}

<update id="updateByPrimaryKey" parameterType="com.singerw.pojo.Article">
    <!--@mbg.generated-->
    update article
    set article_title   = #{articleTitle,jdbcType=LONGVARCHAR},
    article_content = #{articleContent,jdbcType=LONGVARCHAR},
    head_image      = #{headImage,jdbcType=VARCHAR},
    article_author  = #{articleAuthor,jdbcType=VARCHAR},
    type_number     = #{typeNumber,jdbcType=INTEGER},
    pageviews       = #{pageviews,jdbcType=INTEGER},
    create_time     = #{createTime,jdbcType=TIMESTAMP},
    is_state        = #{isState,jdbcType=INTEGER},
    version         = #{version,jdbcType=INTEGER}
    where a_id = #{aId,jdbcType=INTEGER}
    and version = #{version,jdbcType=INTEGER}
</update>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 步骤三：Service接口

public interface ArticleService {

    void testUptateLock3(Integer aId);

    void testUptateLock4(Integer aId);

}
1
2
3
4
5
6
7

# 步骤四：ServiceImpl实现类

@Service
public class ArticleServiceImpl implements ArticleService {

    @Resource
    private ArticleMapper articleMapper;


    @Override
    @Transactional
    public void testUptateLock3(Integer aId) {
        // 1 先做查询
        Article article = articleMapper.selectByPrimaryKey(aId);

        // 2 修改对象的属性值
        article.setArticleTitle("乐观锁_lock测试的Title_3");

        // 模拟其他的业务
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 3 调用修改的方法
        int result = articleMapper.updateByPrimaryKeySelective(article);
    }

    @Override
    @Transactional
    public void testUptateLock4(Integer aId) {
        // 1 先做查询
        Article article = articleMapper.selectByPrimaryKey(aId);

        // 2 修改对象的属性值
        article.setArticleTitle("乐观锁_lock测试的Title_4");

        // 3 调用修改的方法
        int result = articleMapper.updateByPrimaryKeySelective(article);
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 步骤五：控制器

@RestController
@RequestMapping("/api")
public class ArticleController {

    @Autowired
    private ArticleService articleService;

    @GetMapping("/updateLock03/{aId}")
    public String updateLock03(@PathVariable("aId") Integer aId){
        articleService.testUptateLock3(aId);
        return "updateLock03 OK!";
    }

    @GetMapping("/updateLock04/{aId}")
    public String updateLock04(@PathVariable("aId") Integer aId){
        articleService.testUptateLock4(aId);
        return "updateLock04 OK!";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 步骤六：访问进行测试

优先访问：updateLock03 ===>/updateLock03/{aId}

再访问下：updateLock04===> /updateLock04/{aId}

# 总结

发现实际的效果，第二个请求updateLock04并没有等第一个请求updateLock03 结束后才响应；直接响应，并更新成功;

然后，当我们第二个请求提交成功后，第一个请求经过10s，也尝试提交，但是，修改失败，因为version版本号已经被updateLock04给修改了,所有updateLock03 无法再进行提交。

对于mybatis中实现乐观锁，就是sql语句的实现，如果没有更新成功，不会报异常，直接就是受影响的行为0而已;

#

编辑 (opens new window)
#SpringBoot#乐观锁#悲观锁
Maven资源导出问题终极版

←

最近更新
01
Maven资源导出问题终极版
 10-12
02
《MyBatis-Plus》学习笔记
 10-07
03
MyBatis-Plus—配置日志
 10-07
更多文章>
Theme by Vdoing | Copyright © 2020-2021 版权所有 | repository.singerw.com
×