在用MySQL时，不知你是否会疑问：同时有很多做更新、插入、删除动作，MySQL如何保证数据不出错呢？

MySQL中自带了锁的功能，可以帮助我们实现开发过程中遇到的同时处理数据的情况。对于数据库中的锁，从锁的范围来讲有：

  • 表级锁，即A操作表时，其他人对整个表都不能操作，等待A操作完之后，才能继续。
  • 行级锁，即A操作表时，其他人对指定的行数据不能操作，其他行可以操作，等待A操作完之后，才能继续。
  1. MYISAM支持表锁，不支持行锁；
  2. InnoDB引擎支持行锁和表锁。
  4. 即：在MYISAM下如果要加锁，无论怎么加都会是表锁。
  5.     在InnoDB引擎支持下如果是基于索引查询的数据则是行级锁，否则就是表锁。

所以，一般情况下我们会选择使用innodb引擎，并且在 搜索 时也会使用索引（命中索引）。
在innodb引擎中，update、insert、delete的行为内部都会先申请锁（排它锁），申请到之后才执行相关操作，最后再释放锁。

  1. 所以，当多个人同时像数据库执行：insert、update、delete等操作时，内部加锁后会排队逐一执行。

而select则默认不会申请锁。

  1. select * from xxx;

如果，你想要让select去申请锁，则需要配合 事务 + 特殊语法来实现。

  • for update，排它锁，加锁之后，其他不可以读写。 

    1. begin; 
    2.  select * from L1 where name="mufeng" for update;    -- name列不是索引（表锁）
    3. commit;
    1. begin; -- 或者 start transaction;
    2.  select * from L1 where id=1 for update;              -- id列是索引（行锁）
    3. commit;

  • lock in share mode ，共享锁，加锁之后，其他可读但不可写。 

    1. begin; 
    2.  select * from L1 where name="mufeng" lock in share mode;    -- 假设name列不是索引（表锁）
    3. commit;
    1. begin; -- 或者 start transaction;
    2.  select * from L1 where id=1 lock in share mode;           -- id列是索引（行锁）
    3. commit;

    排它锁

    排它锁（ for update），加锁之后，其他事务不可以读写。
    应用场景：总共100件商品，每次购买一件需要让商品个数减1 。 ```plsql A: 访问页面查看商品剩余 100 B: 访问页面查看商品剩余 100

此时 A、B 同时下单，那么他们同时执行SQL： update goods set count=count-1 where id=3 由于Innodb引擎内部会加锁，所以他们两个即使同一时刻执行，内部也会排序逐步执行。

但是，当商品剩余 1个时，就需要注意了。 A: 访问页面查看商品剩余 1 B: 访问页面查看商品剩余 1

此时 A、B 同时下单，那么他们同时执行SQL： update goods set count=count-1 where id=3 这样剩余数量就会出现 -1，很显然这是不正确的，所以应该怎么办呢？

这种情况下，可以利用 排它锁，在更新之前先查询剩余数量，只有数量 >0 才可以购买，所以，下单时应该执行： begin; — start transaction; select count from goods where id=3 for update; — 获取个数进行判断 if 个数>0: update goods set count=count-1 where id=3; else: — 已售罄 commit;

  1. 基于Python代码示例：
  2. ```plsql
  3. import pymysql
  4. import threading
  7. def task():
  8.     conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='root', charset="utf8", db='db1')
  9.     cursor = conn.cursor(pymysql.cursors.DictCursor)
  10.     # cursor = conn.cursor()
  12.     # 开启事务
  13.     conn.begin()
  15.     cursor.execute("select id,age from tran where id=2 for update")
  16.     # fetchall      ( {"id":1,"age":10},{"id":2,"age":10}, )   ((1,10),(2,10))
  17.     # {"id":1,"age":10}   (1,10)
  18.     result = cursor.fetchone()
  19.     current_age = result['age']
  21.     if current_age > 0:
  22.         cursor.execute("update tran set age=age-1 where id=2")
  23.     else:
  24.         print("已售罄")
  26.     conn.commit()
  28.     cursor.close()
  29.     conn.close()
  32. def run():
  33.     for i in range(5):
  34.         t = threading.Thread(target=task)
  35.         t.start()
  38. if __name__ == '__main__':
  39.     run()

共享锁

使用的较少。
共享锁（ lock in share mode），可以读，但不允许写。
加锁之后，后续其他事物可以可以进行读，但不允许写（update、delete、insert），因为写的默认也会加锁。