您的位置: 首页  >  文章  >  乐观锁悲观锁

乐观锁悲观锁

分类: 文章 • 2022-12-24 00:03:20

乐观锁

谈到了MySQL悲观锁，但是悲观锁并不是适用于任何场景，它也有它存在的一些不足，因为悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。如果加锁的时间过长，其他用户长时间无法访问，影响了程序的并发访问性，同时这样对数据库性能开销影响也很大，特别是对长事务而言，这样的开销往往无法承受。所以与悲观锁相对的，我们有了乐观锁，具体参见下面介绍：

乐观锁介绍：

乐观锁（ Optimistic Locking ） 相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。
乐观锁悲观锁

如上图所示，如果更新操作顺序执行，则数据的版本（version）依次递增，不会产生冲突。但是如果发生有不同的业务操作对同一版本的数据进行修改，那么，先提交的操作（图中B）会把数据version更新为2，当A在B之后提交更新时发现数据的version已经被修改了，那么A的更新操作会失败。

乐观锁的第二种实现方式和第一种差不多，同样是在需要乐观锁控制的table中增加一个字段，名称无所谓，字段类型使用时间戳（timestamp）, 和上面的version类似，也是在更新提交的时候检查当前数据库中数据的时间戳和自己更新前取到的时间戳进行对比，如果一致则OK，否则就是版本冲突。

相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。

如一个金融系统，当某个操作员读取用户的数据，并在读出的用户数据的基础上进行修改时（如更改用户帐户余额），如果采用悲观锁机制，也就意味着整个操作过程中（从操作员读出数据、开始修改直至提交修改结果的全过程，甚至还包括操作员中途去煮咖啡的时间），数据库记录始终处于加锁状态，可以想见，如果面对几百上千个并发，这样的情况将导致怎样的后果。

乐观锁机制在一定程度上解决了这个问题。

乐观锁，大多是基于数据版本（Version）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来实现。

读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

对于上面修改用户帐户信息的例子而言，假设数据库中帐户信息表中有一个version 字段，当前值为 1 ，而当前帐户余额字段（ balance ）为 $100 。

  1. 操作员 A 此时将其读出（ version=1 ），并从其帐户余额中扣除50（100-$50 ）

  2. 在操作员 A 操作的过程中，操作员 B 也读入此用户信息（ version=1 ），并从其帐户余额中扣除 20（100-$20 ）。

  3. 操作员 A 完成了修改工作，将数据版本号加一（ version=2 ），连同帐户扣除后余额（ balance=$50 ），提交至数据库更新，此时由于提交数据版本大于数据库记录当前版本，数据被更新，数据库记录 version 更新为 2 。

  4. 操作员 B 完成了操作，也将版本号加一（ version=2 ）试图向数据库提交数据（ balance=$80 ），但此时比对数据库记录版本时发现，操作员 B 提交的数据版本号为 2 ，数据库记录当前版本也为 2 ，不满足 “ 提交版本必须大于记录当前版本才能执行更新 “ 的乐观锁策略，因此，操作员 B 的提交被驳回。

这样，就避免了操作员 B 用基于 version=1 的旧数据修改的结果覆盖操作员 A 的操作结果的可能。

从上面的例子可以看出，乐观锁机制避免了长事务中的数据库加锁开销（操作员A统整体性能表现。需要注意的是，乐观锁机制往往基于系统中的数据存储逻辑，因此也具备一定的局限性，如在上例中，由于乐观锁机制是在我们的系统中实现，来自外部系统的用户余额更新操作不受我们系统的控制，因此可能会造成脏数据被更新到数据库中。在系统设计阶段，我们应该充分考虑到这些情况出现的可能性，并进行相应调整（如将乐观锁策略在数据库存储过程中实现，对外只开放基于此存储过程的数据更新途径，而不是将数据库表直接对外公开）。

悲观锁

悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。

如果不采用锁，那么操作方法如下：

  1. 查询出商品信息
    select status from t_goods where id=1;
  2. 根据商品信息生成订单
    insert into t_orders (id,goods_id) values (null,1);
  3. 修改商品status为2
    update t_goods set status=2;

上面这种场景在高并发访问的情况下很可能会出现问题。
前面已经提到，只有当goods status为1时才能对该商品下单，上面第一步操作中，查询出来的商品status为1。但是当我们执行第三步Update操作的时候，有可能出现其他人先一步对商品下单把goods status修改为2了，但是我们并不知道数据已经被修改了，这样就可能造成同一个商品被下单2次，使得数据不一致。所以说这种方式是不安全的。

使用悲观锁来实现：

在上面的场景中，商品信息从查询出来到修改，中间有一个处理订单的过程，使用悲观锁的原理就是，当我们在查询出goods信息后就把当前的数据锁定，直到我们修改完毕后再解锁。那么在这个过程中，因为goods被锁定了，就不会出现有第三者来对其进行修改了。

注：要使用悲观锁，我们必须关闭mysql数据库的自动提交属性，因为MySQL默认使用autocommit模式，也就是说，当你执行一个更新操作后，MySQL会立刻将结果进行提交。

我们可以使用命令设置MySQL为非autocommit模式：
set autocommit=0;

设置完autocommit后，我们就可以执行我们的正常业务了。具体如下：
0. 开始事务
begin;/begin work;/start transaction; (三者选一就可以)
1. 查询出商品信息
select status from t_goods where id=1 for update;
2. 根据商品信息生成订单
insert into t_orders (id,goods_id) values (null,1);
3. 修改商品status为2
update t_goods set status=2;
4. 提交事务
commit;/commit work;

sessison1 :
SET AUTOCOMMIT=0;
BEGIN WORK;
SELECT name FROM user WHERE id = 0 FOR UPDATE;
COMMIT WORK;

session2:
SELECT name FROM user WHERE loginname = ‘admin’ for update;

注：上面的begin/commit为事务的开始和结束，因为在前一步我们关闭了mysql的autocommit，所以需要手动控制事务的提交，在这里就不细表了。

上面的第一步我们执行了一次查询操作：select status from t_goods where id=1 for update;
与普通查询不一样的是，我们使用了select…for update的方式，这样就通过数据库实现了悲观锁。此时在t_goods表中，id为1的 那条数据就被我们锁定了，其它的事务必须等本次事务提交之后才能执行。这样我们可以保证当前的数据不会被其它事务修改。

注：需要注意的是，在事务中，只有SELECT … FOR UPDATE 或LOCK IN SHARE MODE 同一笔数据时会等待其它事务结束后才执行，一般SELECT … 则不受此影响。拿上面的实例来说，当我执行select status from t_goods where id=1 for update;后。我在另外的事务中如果再次执行select status from t_goods where id=1 for update;则第二个事务会一直等待第一个事务的提交，此时第二个查询处于阻塞的状态，但是如果我是在第二个事务中执行select status from t_goods where id=1;则能正常查询出数据，不会受第一个事务的影响。

补充：MySQL select…for update的Row Lock与Table Lock
上面我们提到，使用select…for update会把数据给锁住，不过我们需要注意一些锁的级别，MySQL InnoDB默认Row-Level Lock，所以只有「明确」地指定主键，MySQL 才会执行Row lock (只锁住被选取的数据) ，否则MySQL 将会执行Table Lock (将整个数据表单给锁住)。

总结：
两种锁都是为了解决并发情况下的写冲突
1、对于数据更新频繁的场所，悲观锁效果更高
2、对于数据更新不频繁的场所，乐观锁效率更高
3、当你执行select xx from xx where xx for update后，在另一个事务中如果对同一张表再次执行select xx from xx where xx for update，那么第二个事务会一直等到第一个事务结束才会被触发，也就是一直处于阻塞的状态，无法查询。可以看到在数据更新不频繁的时候，悲观锁效率很低。
相反，当数据更新频繁的时候，乐观锁的效率很低，因为基本上每次写的时候都要重复读写两次以上。
4、A更新成功之后，version++
B在尝试更新的时候，发现欲更新的记录的的ver跟数据库对应记录的ver不一致。于是重新读取该记录，也就是A更新之后的记录。
至于重新读取之后是怎样提示用户，就是你UX的设计问题了，跟数据库这边无关。
A的更新是保存到了数据库的。B要再更新，必须基于A的更新之上。

智慧运河中需要加锁机制的逻辑（乐观锁）：
1、卡券模块
1）削减库存操作：update coupon set quantity = quantity-1 where coupon_id = #{cardId}
微信回调之后，修改该卡券的库存，不需要加锁更新
2）更改卡券本地数据库状态：update coupon set status = #{status} where coupon_id = #{cardId}
微信回调之后，修改卡券本地数据库状态，不需要加锁更新，卡券的审核通过与不通过只会有一种情况
2、设备模块
1）根据设备号删除设备：delete from mch_dv where device_no = #{device_no}
用户在页面可以点击删除然后删除设备，不需要加锁，一个用户取消了绑定，另一个再次取消不会出现问题，测试可知
2）设备绑定店铺，需要增加事务的概念
第一步更改设备状态： update dev_devices set status = #{status} where en = #{en}
第二步插入店铺设备关联表：insert into mch_dv(mcode,en) values(#{mcode},#{en})

程序中需要回滚的情景：
1、例如设备绑定店铺分两次数据库操作完成
1）把设备表（dev_devices）中的状态改为已绑定
2）在设备-店铺关联表中（mcn_dv）插入一条数据

mysql事务管理使用方法如下

spring-mybatis框架事务的使用
自动提交

默认情况下，数据库处于自动提交模式。每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则隐式的提交事务，如果
执行失败则隐式的回滚事务。

对于正常的事务管理，是一组相关的操作处于一个事务之中，因此必须关闭数据库的自动提交模式。不过，这个我们不用担心，spring会将底层连接的自动提交特性设置为false。

applicationContext.xml中设置事务管理：

使用注解事务管理的方法：

Propagation.REQUIRED 。 默认值 。当前方法必须在Transaction中运行。如果存在已经定义的Transaction，则该方法在已定义的Transaction中运行；如果不存在已经定义的Transaction，则该方法新开一个Transaction并在其中运行。

相关推荐