1、MyISAM和InnoDB支持的锁类型
-
相对其他数据库而言，MySQL的锁机制比较简单，其最显著的特点是不同的存储引擎支持不同的锁机制。
-
MyISAM和MEMORY存储引擎采用的是表级锁（table-level locking）。
-
InnoDB存储引擎既支持行级锁（row-level locking），也支持表级锁，但默认情况下是采用行级锁。
2、MySQL这3种锁的特性
1）行级锁
-
行级锁分为共享锁和排它锁,行级锁是Mysql中锁定粒度最细的锁。
-
InnoDB引擎支持行级锁和表级锁，只有在通过索引条件检索数据的时候，才使用行级锁，否就使用表级锁。
-
行级锁开销大，加锁慢，锁定粒度最小，发生锁冲突概率最低，并发度最高
举例： 只根据主键进行查询，并且查询到数据，主键字段产生行锁。
#### 行锁
'''
client1中执行：
select * from shop where id=1 for update;
clenet2中执行：
select * from shop where id=2 for update; # 可以正常放回数据
select * from shop where id=1 for update; # 阻塞
'''
# 可以看到：id是主键，当在client1上查询id=1的数据时候，在client2上查询id=2的数据没问题
# 但在client2上查询id=1的数据时阻塞，说明此时的锁时行锁。
# 当client1执行commit时，clinet2查询的id=1的命令立即返回数据。
2）表级锁
-
表级锁分为表共享锁和表独占锁。
-
表级锁开销小，加锁快，锁定粒度大、发生锁冲突最高，并发度最低
举例：根据非主键不含索引（name）进行查询，并且查询到数据，name字段产生表锁。
#### 表锁
# 可以看到，client1通过非索引的name字段查询到prod11的数据后，在client2查prod**的数据会阻塞，产生表锁。
'''
client1中执行：
select * from shop where name="prod11" for update;
clenet2中执行：
select * from shop where name="prod**" for update;
'''
3）页级锁
-
页级锁是MySQL中锁定粒度介于行级锁和表级锁中间的一种锁。
-
表级锁速度快，但冲突多，行级冲突少，但速度慢。
-
所以取了折衷的页级，一次锁定相邻的一组记录,BDB支持页级锁。
-
开销和加锁时间界于表锁和行锁之间；会出现死锁；锁定粒度界于表锁和行锁之间，并发度一般。
总结：
-
表级锁更适合于以查询为主，只有少量按索引条件更新数据的应用，如Web应用；
-
而行级锁则更适合于有大量按索引条件并发更新少量不同数据，同时又有并发查询的应用，如一些在线事务处理（OLTP）系统。
3、锁分类
-
按操作划分：DML锁，DDL锁
-
按锁的粒度划分：表级锁、行级锁、页级锁
-
按锁级别划分：共享锁、排他锁
-
按加锁方式划分：自动锁、显示锁
-
按使用方式划分：乐观锁、悲观锁
4、乐观锁悲观锁作用
-
在并发访问情况下，很有可能出现不可重复读等等读现象。
-
为了更好的应对高并发，封锁、时间戳、乐观并发控制(乐观锁)、悲观并发控制(悲观锁)都是并发控制采用的主要技术方式。
5、悲观锁
-
悲观锁的实现，往往依靠数据库提供的锁机制
-
MySQL会对查询结果集中每行数据都添加排他锁，其他线程对该记录的更新与删除操作都会阻塞，排他锁包含行锁、表锁。
-
申请前提：没有线程对该结果集中的任何行数据使用排他锁或共享锁，否则申请会阻塞。
适用场景：悲观锁适合写入频繁的场景。
注：
首先我们需要set autocommit=0，即不允许自动提交
用法：select * from tablename where id = 1 for update;
6、乐观锁
-
在更新数据的时候需要比较程序中的库存量与数据库中的库存量是否相等，如果相等则进行更新。
-
反之程序重新获取库存量，再次进行比较，直到两个库存量的数值相等才进行数据更新。
7、举例：对商品数量-1操作
1）悲观锁实现方法
-
每次获取商品时，对该商品加排他锁。
-
也就是在用户A获取获取 id=1 的商品信息时对该行记录加锁，期间其他用户阻塞等待访问该记录。
悲观锁
#### 悲观锁实现加一操作代码
# 我们可以看到，首先通过begin开启一个事物，在获得shop信息和修改数据的整个过程中都对数据加锁，保证了数据的一致性。
'''
begin;
select id,name,stock as old_stock from shop where id=1 for update;
update shop set stock=stock-1 where id=1 and stock=old_stock;
commit
'''
python使用悲观锁
SKU.objects.select_for_update().get(id=1)
2）乐观锁实现方法
-
每次获取商品时，不对该商品加锁。
-
在更新数据的时候需要比较程序中的库存量与数据库中的库存量是否相等，如果相等则进行更新
-
反之程序重新获取库存量，再次进行比较，直到两个库存量的数值相等才进行数据更新。
乐观锁
#### 乐观锁实现加一操作代码
# 我们可以看到，只有当对数量-1操作时才会加锁，只有当程序中值和数据库中的值相等时才正真执行。
'''
//不加锁
select id,name,stock where id=1;
//业务处理
begin;
update shop set stock=stock-1 where id=1 and stock=stock;
commit;
'''
python使用乐观锁
SKU.objects.filter(id=1, stock=7).update(stock=2)SKU.objects.filter(id=1, stock=7).update(stock=2)
8、python适用乐观锁解决事物问题
使用 django.db.transaction 模块解决MySQL 事物管理 问题
-
在事务当前启动celery异步任务, 无法获取未提交的改动.
-
在使用transaction当中, Model.save()都不做commit .
-
因此如果在transaction当中设置异步任务,使用get()查询数据库,将看不到对象在事务当中的改变.
-
这也是实现”可重复读”的事务隔离级别,即同一个事务里面的多次查询都应该保持结果不变.
使用transaction模块解决mysql事物问题
# with语句用法
from django.db import transaction
def viewfunc(request):
# 这部分代码不在事务中，会被Django自动提交
...
with transaction.atomic():
# 这部分代码会在事务中执行
...
'''
from django.db import transaction
# 创建保存点
save_id = transaction.savepoint()
# 回滚到保存点
transaction.savepoint_rollback(save_id)
# 提交从保存点到当前状态的所有数据库事务操作
transaction.savepoint_commit(save_id)
'''
transaction使用实例
from django.db import transaction
def create(self, validated_data):
"""
保存订单
"""
# 获取当前下单用户
user = self.context['request'].user
# 组织订单编号 20170903153611+user.id
# timezone.now() -> datetime
order_id = timezone.now().strftime('%Y%m%d%H%M%S') + ('%09d' % user.id)
address = validated_data['address']
pay_method = validated_data['pay_method']
# 生成订单
with transaction.atomic():
# 创建一个保存点
save_id = transaction.savepoint()
try:
# 创建订单信息
order = OrderInfo.objects.create(
order_id=order_id,
user=user,
address=address,
total_count=0,
total_amount=Decimal(0),
freight=Decimal(10),
pay_method=pay_method,
status=OrderInfo.ORDER_STATUS_ENUM['UNSEND'] if pay_method == OrderInfo.PAY_METHODS_ENUM['CASH'] else OrderInfo.ORDER_STATUS_ENUM['UNPAID']
)
# 获取购物车信息
redis_conn = get_redis_connection("cart")
redis_cart = redis_conn.hgetall("cart_%s" % user.id)
cart_selected = redis_conn.smembers('cart_selected_%s' % user.id)
# 将bytes类型转换为int类型
cart = {}
for sku_id in cart_selected:
cart[int(sku_id)] = int(redis_cart[sku_id])
# 一次查询出所有商品数据
skus = SKU.objects.filter(id__in=cart.keys())
# 处理订单商品
for sku in skus:
sku_count = cart[sku.id]
# 判断库存
origin_stock = sku.stock # 原始库存
origin_sales = sku.sales # 原始销量
if sku_count > origin_stock:
transaction.savepoint_rollback(save_id)
raise serializers.ValidationError('商品库存不足')
# 用于演示并发下单
# import time
# time.sleep(5)
# 减少库存
new_stock = origin_stock - sku_count
new_sales = origin_sales + sku_count
sku.stock = new_stock
sku.sales = new_sales
sku.save()
# 累计商品的SPU 销量信息
sku.goods.sales += sku_count
sku.goods.save()
# 累计订单基本信息的数据
order.total_count += sku_count # 累计总金额
order.total_amount += (sku.price * sku_count) # 累计总额
# 保存订单商品
OrderGoods.objects.create(
order=order,
sku=sku,
count=sku_count,
price=sku.price,
)
# 更新订单的金额数量信息
order.total_amount += order.freight
order.save()
except ValidationError:
raise
except Exception as e:
logger.error(e)
transaction.savepoint_rollback(save_id)
raise
# 提交事务
transaction.savepoint_commit(save_id)
# 更新redis中保存的购物车数据
pl = redis_conn.pipeline()
pl.hdel('cart_%s' % user.id, *cart_selected)
pl.srem('cart_selected_%s' % user.id, *cart_selected)
pl.execute()
return order
9、MySQL中 共享锁 和 排它锁
1）排它锁
-
排它锁又叫写锁，如果事务T对A加上排它锁，则其它事务都不能对A加任何类型的锁。获准排它锁的事务既能读数据，又能写数据。
-
用法 ： SELECT … FOR UPDATE
2）共享锁(share lock)
-
共享锁又叫读锁，如果事务T对A加上共享锁，则其它事务只能对A再加共享锁，不能加其它锁。
-
获准共享锁的事务只能读数据，不能写数据。
-
用法： SELECT … LOCK IN SHARE MODE;
68
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
