数据库管理系统(DBMS)中的并发控制的任务是确保在多个事务同时存取数据库中同一数据时不破坏事务的隔离性和统一性以及数据库的统一性。下面举例说明并发操作可能带来的数据不一致性问题:
现有两处火车票售票点,同时读取某一趟列车车票数据库中车票余额为X。两处售票点同时卖出一张车票,同时修改余额为X-1并写回数据库,这样就造成了实际卖出两张火车票而数据库中的记录却只少了一张。 产生这种情况的原因是因为两个事务读入同一数据并同时修改,其中一个事务提交的结果破坏了另一个事务提交的结果,导致其数据的修改被丢失,破坏了事务的隔离性。并发控制要解决的就是这类问题。
封锁、时间戳、乐观并发控制(乐观锁)和悲观并发控制(悲观锁)是并发控制主要采用的技术手段。
锁
当并发事务同时访问一个资源时,有可能导致数据不一致,因此需要一种机制来将数据访问顺序化,以保证数据库数据的一致性。锁就是其中的一种机制。
在计算机科学中,锁是在执行多线程时用于强行限制资源访问的同步机制,即用于在并发控制中保证对互斥要求的满足。
锁的分类(oracle)
按操作划分,可分为DML锁、DDL锁; 按锁的粒度划分,可分为表级锁、行级锁、页级锁(MySQL); 按锁级别划分,可分为共享锁、排他锁; 按加锁方式划分,可分为自动锁、显示锁; 按使用方式划分,可分为乐观锁、悲观锁。DML锁(data locks,数据锁),用于保护数据的完整性,其中包括行级锁(Row Locks,即TX锁)、表级锁(table lock,即TM锁).
DDL锁(dictionary locks,数据字典锁),用于保护数据库对象的结构,如表、索引等的结构定义,其中包括排他DDL锁(Exclusive DDL lock)、共享DDL锁(Share DDL lock)和可中断解析锁(Breakable parse locks)。
1 前言
数据库大并发操作要考虑死锁和锁的性能问题。看到网上大多语焉不详(尤其更新锁),所以这里做个简明解释,为下面描述方便,这里用T1代表一个数据库执行请求,T2代表另一个请求,也可以理解为T1为一个线程,T2 为另一个线程。T3,T4以此类推。
2 锁的种类
- 共享锁(Shared lock)。
例1: ---------------------------------------- T1: select * from table (请想象它需要执行1个小时之久,后面的sql语句请都这么想象) T2: update table set column1='hello' 过程: T1运行 (加共享锁) T2运行 If T1 还没执行完 T2等...... else 锁被释放 T2执行 endif T2之所以要等,是因为T2在执行update前,试图对table表加一个排他锁, 而数据库规定同一资源上不能同时共存共享锁和排他锁。所以T2必须等T1 执行完,释放了共享锁,才能加上排他锁,然后才能开始执行update语句。 例2: ---------------------------------------- T1: select * from table T2: select * from table 这里T2不用等待T1执行完,而是可以马上执行。 分析: T1运行,则table被加锁,比如叫lockA T2运行,再对table加一个共享锁,比如叫lockB。 两个锁是可以同时存在于同一资源上的(比如同一个表上)。这被称为共 享锁与共享锁兼容。这意味着共享锁不阻止其它session同时读资源,但阻 止其它session update 例3: ---------------------------------------- T1: select * from table T2: select * from table T3: update table set column1='hello' 这次,T2不用等T1运行完就能运行,T3却要等T1和T2都运行完才能运行。 因为T3必须等T1和T2的共享锁全部释放才能进行加排他锁然后执行update 操作。 例4:(死锁的发生) ---------------------------------------- T1: begin tran select * from table (holdlock) (holdlock意思是加共享锁,直到事物结束才释放) update table set column1='hello' T2: begin tran select * from table(holdlock) update table set column1='world' 假设T1和T2同时达到select,T1对table加共享锁,T2也对加共享锁,当 T1的select执行完,准备执行update时,根据锁机制,T1的共享锁需要升 级到排他锁才能执行接下来的update.在升级排他锁前,必须等table上的 其它共享锁释放,但因为holdlock这样的共享锁只有等事务结束后才释放, 所以因为T2的共享锁不释放而导致T1等(等T2释放共享锁,自己好升级成排 他锁),同理,也因为T1的共享锁不释放而导致T2等。死锁产生了。 例5: ---------------------------------------- T1: begin tran update table set column1='hello' where id=10 T2: begin tran update table set column1='world' where id=20 这种语句虽然最为常见,很多人觉得它有机会产生死锁,但实际上要看情 况,如果id是主键上面有索引,那么T1会一下子找到该条记录(id=10的记 录),然后对该条记录加排他锁,T2,同样,一下子通过索引定位到记录, 然后对id=20的记录加排他锁,这样T1和T2各更新各的,互不影响。T2也不 需要等。 但如果id是普通的一列,没有索引。那么当T1对id=10这一行加排他锁后, T2为了找到id=20,需要对全表扫描,那么就会预先对表加上共享锁或更新 锁或排他锁(依赖于数据库执行策略和方式,比如第一次执行和第二次执行 数据库执行策略就会不同)。但因为T1已经为一条记录加了排他锁,导致 T2的全表扫描进行不下去,就导致T2等待。 死锁怎么解决呢?一种办法是,如下: 例6: ---------------------------------------- T1: begin tran select * from table(xlock) (xlock意思是直接对表加排他锁) update table set column1='hello' T2: begin tran select * from table(xlock) update table set column1='world' 这样,当T1的select 执行时,直接对表加上了排他锁,T2在执行select时,就需要等T1事物完全执行完才能执行。排除了死锁发生。 但当第三个user过来想执行一个查询语句时,也因为排他锁的存在而不得不等待,第四个、第五个user也会因此而等待。在大并发 情况下,让大家等待显得性能就太友好了,所以,这里引入了更新锁。
- 更新锁(Update lock)
为解决死锁,引入更新锁。 例7: ---------------------------------------- T1: begin tran select * from table(updlock) (加更新锁) update table set column1='hello' T2: begin tran select * from table(updlock) update table set column1='world' 更新锁的意思是:“我现在只想读,你们别人也可以读,但我将来可能会做更新操作,我已经获取了从共享锁(用来读)到排他锁 (用来更新)的资格”。一个事物只能有一个更新锁获此资格。 T1执行select,加更新锁。 T2运行,准备加更新锁,但发现已经有一个更新锁在那儿了,只好等。 当后来有user3、user4...需要查询table表中的数据时,并不会因为T1的select在执行就被阻塞,照样能查询,相比起例6,这提高 了效率。 例8: ---------------------------------------- T1: select * from table(updlock) (加更新锁) T2: select * from table(updlock) (等待,直到T1释放更新锁,因为同一时间不能在同一资源上有两个更新锁) T3: select * from table (加共享锁,但不用等updlock释放,就可以读) 这个例子是说明:共享锁和更新锁可以同时在同一个资源上。这被称为共享锁和更新锁是兼容的。 例9: ---------------------------------------- T1: begin select * from table(updlock) (加更新锁) update table set column1='hello' (重点:这里T1做update时,不需要等T2释放什么,而是直接把更新锁升级为排他锁,然后执行update) T2: begin select * from table (T1加的更新锁不影响T2读取) update table set column1='world' (T2的update需要等T1的update做完才能执行) 我们以这个例子来加深更新锁的理解, 第一种情况:T1先达,T2紧接到达;在这种情况中,T1先对表加更新锁,T2对表加共享锁,假设T2的select先执行完,准备执行update, 发现已有更新锁存在,T2等。T1执行这时才执行完select,准备执行update,更新锁升级为排他锁,然后执行update,执行完成,事务 结束,释放锁,T2才轮到执行update。 第二种情况:T2先达,T1紧接达;在这种情况,T2先对表加共享锁,T1达后,T1对表加更新锁,假设T2 select先结束,准备 update,发现已有更新锁,则等待,后面步骤就跟第一种情况一样了。 这个例子是说明:排他锁与更新锁是不兼容的,它们不能同时加在同一子资源上。
- 排他锁(独占锁,Exclusive Locks)
这个简单,即其它事务既不能读,又不能改排他锁锁定的资源。 例10 T1: update table set column1='hello' where id<1000 T2: update table set column1='world' where id>1000 假设T1先达,T2随后至,这个过程中T1会对id<1000的记录施加排他锁.但不会阻塞T2的update。 例11 (假设id都是自增长且连续的) T1: update table set column1='hello' where id<1000 T2: update table set column1='world' where id>900 如同例10,T1先达,T2立刻也到,T1加的排他锁会阻塞T2的update.
- 意向锁(Intent Locks)
意向锁就是说在屋(比如代表一个表)门口设置一个标识,说明屋子里有人(比如代表某些记录)被锁住了。另一个人想知道屋子 里是否有人被锁,不用进屋子里一个一个的去查,直接看门口标识就行了。 当一个表中的某一行被加上排他锁后,该表就不能再被加表锁。数据库程序如何知道该表不能被加表锁?一种方式是逐条的判断该 表的每一条记录是否已经有排他锁,另一种方式是直接在表这一层级检查表本身是否有意向锁,不需要逐条判断。显然后者效率高。 例12: ---------------------------------------- T1: begin tran select * from table (xlock) where id=10 --意思是对id=10这一行强加排他锁 T2: begin tran select * from table (tablock) --意思是要加表级锁 假设T1先执行,T2后执行,T2执行时,欲加表锁,为判断是否可以加表锁,数据库系统要逐条判断table表每行记录是否已有排他锁, 如果发现其中一行已经有排他锁了,就不允许再加表锁了。只是这样逐条判断效率太低了。 实际上,数据库系统不是这样工作的。当T1的select执行时,系统对表table的id=10的这一行加了排他锁,还同时悄悄的对整个表 加了意向排他锁(IX),当T2执行表锁时,只需要看到这个表已经有意向排他锁存在,就直接等待,而不需要逐条检查资源了。 例13: ---------------------------------------- T1: begin tran update table set column1='hello' where id=1 T2: begin tran update table set column1='world' where id=1 这个例子和上面的例子实际效果相同,T1执行,系统对table同时对行家排他锁、对页加意向排他锁、对表加意向排他锁。
- 计划锁(Schema Locks)
例14: ---------------------------------------- alter table .... (加schema locks,称之为Schema modification (Sch-M) locks DDL语句都会加Sch-M锁 该锁不允许任何其它session连接该表。连都连不了这个表了,当然更不用说想对该表执行什么sql语句了。 例15: ---------------------------------------- 用jdbc向数据库发送了一条新的sql语句,数据库要先对之进行编译,在编译期间,也会加锁,称之为:Schema stability (Sch-S) locks select * from tableA 编译这条语句过程中,其它session可以对表tableA做任何操作(update,delete,加排他锁等等),但不能做DDL(比如alter table)操作。
- Bulk Update Locks 主要在批量导数据时用(比如用类似于oracle中的imp/exp的bcp命令)。不难理解,程序员往往也不需要关心,不赘述了。
3 何时加锁?
如何加锁,何时加锁,加什么锁,你可以通过hint手工强行指定,但大多是数据库系统自动决定的。这就是为什么我们可以不懂锁也可 以高高兴兴的写SQL。 例15: ---------------------------------------- T1: begin tran update table set column1='hello' where id=1 T2: SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED -- 事物隔离级别为允许脏读 go select * from table where id=1 这里,T2的select可以查出结果。如果事物隔离级别不设为脏读,则T2会等T1事物执行完才能读出结果。 数据库如何自动加锁的? 1) T1执行,数据库自动加排他锁 2) T2执行,数据库发现事物隔离级别允许脏读,便不加共享锁。不加共享锁,则不会与已有的排他锁冲突,所以可以脏读。 例16: ---------------------------------------- T1: begin tran update table set column1='hello' where id=1 T2: select * from table where id=1 --为指定隔离级别,则使用系统默认隔离级别,它不允许脏读 如果事物级别不设为脏读,则: 1) T1执行,数据库自动加排他锁 2) T2执行,数据库发现事物隔离级别不允许脏读,便准备为此次select过程加共享锁,但发现加不上,因为已经有排他锁了,所以就 等啊等。直到T1执行完,释放了排他锁,T2才加上了共享锁,然后开始读....
4 锁的粒度
锁的粒度就是指锁的生效范围,就是说是行锁,还是页锁,还是整表锁. 锁的粒度同样既可以由数据库自动管理,也可以通过手工指定hint来管理。
例17: ---------------------------------------- T1: select * from table (paglock) T2: update table set column1='hello' where id>10 T1执行时,会先对第一页加锁,读完第一页后,释放锁,再对第二页加锁,依此类推。假设前10行记录恰好是一页(当然,一般不可能 一页只有10行记录),那么T1执行到第一页查询时,并不会阻塞T2的更新。 例18: ---------------------------------------- T1: select * from table (rowlock) T2: update table set column1='hello' where id=10 T1执行时,对每行加共享锁,读取,然后释放,再对下一行加锁;T2执行时,会对id=10的那一行试图加锁,只要该行没有被T1加上行锁, T2就可以顺利执行update操作。 例19: ---------------------------------------- T1: select * from table (tablock) T2: update table set column1='hello' where id = 10 T1执行,对整个表加共享锁. T1必须完全查询完,T2才可以允许加锁,并开始更新。 以上3例是手工指定锁的粒度,也可以通过设定事物隔离级别,让数据库自动设置锁的粒度。不同的事物隔离级别,数据库会有不同的 加锁策略(比如加什么类型的锁,加什么粒度的锁)。具体请查联机手册。
5 锁与事物隔离级别的优先级
手工指定的锁优先, 例20: ---------------------------------------- T1: GO SET TRANSACTION ISOLATION LEVEL SERIALIZABLE GO BEGIN TRANSACTION SELECT * FROM table (NOLOCK) GO T2: update table set column1='hello' where id=10 T1是事物隔离级别为最高级,串行锁,数据库系统本应对后面的select语句自动加表级锁,但因为手工指定了NOLOCK,所以该select 语句不会加任何锁,所以T2也就不会有任何阻塞。
6 数据库的其它重要Hint以及它们的区别
1) holdlock 对表加共享锁,且事物不完成,共享锁不释放。 2) tablock 对表加共享锁,只要statement不完成,共享锁不释放。 与holdlock区别,见下例: 例21 ---------------------------------------- T1: begin tran select * from table (tablock) T2: begin tran update table set column1='hello' where id = 10 T1执行完select,就会释放共享锁,然后T2就可以执行update. 此之谓tablock. 下面我们看holdlock 例22 ---------------------------------------- T1: begin tran select * from table (holdlock) T2: begin tran update table set column1='hello' where id = 10 T1执行完select,共享锁仍然不会释放,仍然会被hold(持有),T2也因此必须等待而不能update. 当T1最后执行了commit或 rollback说明这一个事物结束了,T2才取得执行权。 3) TABLOCKX 对表加排他锁 例23: ---------------------------------------- T1: select * from table(tablockx) (强行加排他锁) 其它session就无法对这个表进行读和更新了,除非T1执行完了,就会自动释放排他锁。 例24: ---------------------------------------- T1: begin tran select * from table(tablockx) 这次,单单select执行完还不行,必须整个事物完成(执行了commit或rollback后)才会释放排他锁。 4) xlock 加排他锁 那它跟tablockx有何区别呢? 它可以这样用, 例25: ---------------------------------------- select * from table(xlock paglock) 对page加排他锁 而TABLELOCX不能这么用。 xlock还可这么用:select * from table(xlock tablock) 效果等同于select * from table(tablockx)
7 锁的超时等待
例26
SET LOCK_TIMEOUT 4000 用来设置锁等待时间,单位是毫秒,4000意味着等待 4秒可以用select @@LOCK_TIMEOUT查看当前session的锁超时设置。-1 意味着 永远等待。 T1: begin tran udpate table set column1='hello' where id = 10 T2: set lock_timeout 4000 select * from table wehre id = 10
T2执行时,会等待T1释放排他锁,等了4秒钟,如果T1还没有释放排他锁,T2就会抛出异常: Lock request time out period exceeded.
8 附:各种锁的兼容关系表
| Requested mode | IS | S | U | IX | SIX | X | | Intent shared (IS) | Yes | Yes | Yes | Yes | Yes | No | | Shared (S) | Yes | Yes | Yes | No | No | No | | Update (U) | Yes | Yes | No | No | No | No | | Intent exclusive (IX) | Yes | No | No | Yes | No | No | | Shared with intent exclusive (SIX) | Yes | No | No | No | No | No | | Exclusive (X) | No | No | No | No | No | No |
9 如何提高并发效率
- 悲观锁:利用数据库本身的锁机制实现。通过上面对数据库锁的了解,可以根据具体业务情况综合使用事务隔离级别与合理的手工指定锁的方式比如降低锁的粒度等减少并发等待。
- 乐观锁:利用程序处理并发。原理都比较好理解,基本一看即懂。方式大概有以下3种
- 对记录加版本号.
- 对记录加时间戳.
- 对将要更新的数据进行提前读取、事后对比。
MySQL中的行级锁,表级锁,页级锁
在计算机科学中,锁是在执行多线程时用于强行限制资源访问的同步机制,即用于在并发控制中保证对互斥要求的满足。
行级锁
行级锁是Mysql中锁定粒度最细的一种锁,表示只针对当前操作的行进行加锁。行级锁能大大减少数据库操作的冲突。其加锁粒度最小,但加锁的开销也最大。行级锁分为共享锁
和 排他锁
。
特点
开销大,加锁慢;会出现死锁;锁定粒度最小,发生锁冲突的概率最低,并发度也最高。
表级锁
表级锁是MySQL中锁定粒度最大的一种锁,表示对当前操作的整张表加锁,它实现简单,资源消耗较少,被大部分MySQL引擎支持。最常使用的MYISAM与INNODB都支持表级锁定。表级锁定分为表共享读锁
(共享锁)与表独占写锁
(排他锁)。
特点
开销小,加锁快;不会出现死锁;锁定粒度大,发出锁冲突的概率最高,并发度最低。
页级锁
页级锁是MySQL中锁定粒度介于行级锁和表级锁中间的一种锁。表级锁速度快,但冲突多,行级冲突少,但速度慢。所以取了折衷的页级,一次锁定相邻的一组记录。BDB支持页级锁
特点
开销和加锁时间界于表锁和行锁之间;会出现死锁;锁定粒度界于表锁和行锁之间,并发度一般
MySQL常用存储引擎的锁机制
MyISAM和MEMORY采用表级锁(table-level locking)
BDB采用页面锁(page-level locking)或表级锁,默认为页面锁
InnoDB支持行级锁(row-level locking)和表级锁,默认为行级锁
Innodb中的行锁与表锁
前面提到过,在Innodb引擎中既支持行锁也支持表锁,那么什么时候会锁住整张表,什么时候或只锁住一行呢?
InnoDB行锁是通过给索引上的索引项加锁来实现的,这一点MySQL与Oracle不同,后者是通过在数据块中对相应数据行加锁来实现的。InnoDB这种行锁实现特点意味着:只有通过索引条件检索数据,InnoDB才使用行级锁,否则,InnoDB将使用表锁!
在实际应用中,要特别注意InnoDB行锁的这一特性,不然的话,可能导致大量的锁冲突,从而影响并发性能。
行级锁都是基于索引的,如果一条SQL语句用不到索引是不会使用行级锁的,会使用表级锁。行级锁的缺点是:由于需要请求大量的锁资源,所以速度慢,内存消耗大。
行级锁与死锁
MyISAM中是不会产生死锁的,因为MyISAM总是一次性获得所需的全部锁,要么全部满足,要么全部等待。而在InnoDB中,锁是逐步获得的,就造成了死锁的可能。
在MySQL中,行级锁并不是直接锁记录,而是锁索引。索引分为主键索引和非主键索引两种,如果一条sql语句操作了主键索引,MySQL就会锁定这条主键索引;如果一条语句操作了非主键索引,MySQL会先锁定该非主键索引,再锁定相关的主键索引。 在UPDATE、DELETE操作时,MySQL不仅锁定WHERE条件扫描过的所有索引记录,而且会锁定相邻的键值,即所谓的next-key locking。
当两个事务同时执行,一个锁住了主键索引,在等待其他相关索引。另一个锁定了非主键索引,在等待主键索引。这样就会发生死锁。
发生死锁后,InnoDB一般都可以检测到,并使一个事务释放锁回退,另一个获取锁完成事务。
有多种方法可以避免死锁,这里只介绍常见的三种
1、如果不同程序会并发存取多个表,尽量约定以相同的顺序访问表,可以大大降低死锁机会。
2、在同一个事务中,尽可能做到一次锁定所需要的所有资源,减少死锁产生概率;
3、对于非常容易产生死锁的业务部分,可以尝试使用升级锁定颗粒度,通过表级锁定来减少死锁产生的概率;
MySQL中的共享锁与排他锁
共享锁(Share Lock)
共享锁又称读锁,是读取操作创建的锁。其他用户可以并发读取数据,但任何事务都不能对数据进行修改(获取数据上的排他锁),直到已释放所有共享锁。
如果事务T对数据A加上共享锁后,则其他事务只能对A再加共享锁,不能加排他锁。获准共享锁的事务只能读数据,不能修改数据。
用法
SELECT ... LOCK IN SHARE MODE;
在查询语句后面增加LOCK IN SHARE MODE
,Mysql会对查询结果中的每行都加共享锁,当没有其他线程对查询结果集中的任何一行使用排他锁时,可以成功申请共享锁,否则会被阻塞。其他线程也可以读取使用了共享锁的表,而且这些线程读取的是同一个版本的数据。
排他锁(eXclusive Lock)
排他锁又称写锁,如果事务T对数据A加上排他锁后,则其他事务不能再对A加任任何类型的封锁。获准排他锁的事务既能读数据,又能修改数据。
用法
SELECT ... FOR UPDATE;
在查询语句后面增加FOR UPDATE
,Mysql会对查询结果中的每行都加排他锁,当没有其他线程对查询结果集中的任何一行使用排他锁时,可以成功申请排他锁,否则会被阻塞。
意向锁
InnoDB还有两个表锁:
意向共享锁(IS):表示事务准备给数据行加入共享锁,也就是说一个数据行加共享锁前必须先取得该表的IS锁
意向排他锁(IX):类似上面,表示事务准备给数据行加入排他锁,说明事务在一个数据行加排他锁前必须先取得该表的IX锁。
意向锁是InnoDB自动加的,不需要用户干预。
对于insert、update、delete,InnoDB会自动给涉及的数据加排他锁(X);对于一般的Select语句,InnoDB不会加任何锁,事务可以通过以下语句给显示加共享锁或排他锁。
共享锁:SELECT ... LOCK IN SHARE MODE;
排他锁:SELECT ... FOR UPDATE;
乐观锁和悲观锁
乐观并发控制(乐观锁)和悲观并发控制(悲观锁)是并发控制主要采用的技术手段。
无论是悲观锁还是乐观锁,都是人们定义出来的概念,可以认为是一种思想。其实不仅仅是关系型数据库系统中有乐观锁和悲观锁的概念,像memcache、hibernate、tair等都有类似的概念。
针对于不同的业务场景,应该选用不同的并发控制方式。所以,不要把乐观并发控制和悲观并发控制狭义的理解为DBMS中的概念,更不要把他们和数据中提供的锁机制(行锁、表锁、排他锁、共享锁)混为一谈。其实,在DBMS中,悲观锁正是利用数据库本身提供的锁机制来实现的。
下面来分别学习一下悲观锁和乐观锁。
悲观锁
在关系数据库管理系统里,悲观并发控制(又名“悲观锁”,Pessimistic Concurrency Control,缩写“PCC”)是一种并发控制的方法。它可以阻止一个事务以影响其他用户的方式来修改数据。如果一个事务执行的操作都某行数据应用了锁,那只有当这个事务把锁释放,其他事务才能够执行与该锁冲突的操作。
悲观并发控制主要用于数据争用激烈的环境,以及发生并发冲突时使用锁保护数据的成本要低于回滚事务的成本的环境中。
悲观锁,正如其名,它指的是对数据被外界(包括本系统当前的其他事务,以及来自外部系统的事务处理)修改持保守态度(悲观),因此,在整个数据处理过程中,将数据处于锁定状态。 悲观锁的实现,往往依靠数据库提供的锁机制 (也只有数据库层提供的锁机制才能真正保证数据访问的排他性,否则,即使在本系统中实现了加锁机制,也无法保证外部系统不会修改数据)
在数据库中,悲观锁的流程如下:
在对任意记录进行修改前,先尝试为该记录加上排他锁(exclusive locking)。
如果加锁失败,说明该记录正在被修改,那么当前查询可能要等待或者抛出异常。 具体响应方式由开发者根据实际需要决定。
如果成功加锁,那么就可以对记录做修改,事务完成后就会解锁了。
其间如果有其他对该记录做修改或加排他锁的操作,都会等待我们解锁或直接抛出异常。
MySQL InnoDB中使用悲观锁
要使用悲观锁,我们必须关闭mysql数据库的自动提交属性,因为MySQL默认使用autocommit模式,也就是说,当你执行一个更新操作后,MySQL会立刻将结果进行提交。
set autocommit=0;
//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;
上面的查询语句中,我们使用了select…for update
的方式,这样就通过开启排他锁的方式实现了悲观锁。此时在t_goods表中,id为1的 那条数据就被我们锁定了,其它的事务必须等本次事务提交之后才能执行。这样我们可以保证当前的数据不会被其它事务修改。
上面我们提到,使用
select…for update
会把数据给锁住,不过我们需要注意一些锁的级别,MySQL InnoDB默认行级锁。行级锁都是基于索引的,如果一条SQL语句用不到索引是不会使用行级锁的,会使用表级锁把整张表锁住,这点需要注意。
优点与不足
悲观并发控制实际上是“先取锁再访问”的保守策略,为数据处理的安全提供了保证。但是在效率方面,处理加锁的机制会让数据库产生额外的开销,还有增加产生死锁的机会;另外,在只读型事务处理中由于不会产生冲突,也没必要使用锁,这样做只能增加系统负载;还有会降低了并行性,一个事务如果锁定了某行数据,其他事务就必须等待该事务处理完才可以处理那行数
乐观锁
在关系数据库管理系统里,乐观并发控制(又名“乐观锁”,Optimistic Concurrency Control,缩写“OCC”)是一种并发控制的方法。它假设多用户并发的事务在处理时不会彼此互相影响,各事务能够在不产生锁的情况下处理各自影响的那部分数据。在提交数据更新之前,每个事务会先检查在该事务读取数据后,有没有其他事务又修改了该数据。如果其他事务有更新的话,正在提交的事务会进行回滚。乐观事务控制最早是由孔祥重(H.T.Kung)教授提出。
乐观锁( Optimistic Locking ) 相对悲观锁而言,乐观锁假设认为数据一般情况下不会造成冲突,所以在数据进行提交更新的时候,才会正式对数据的冲突与否进行检测,如果发现冲突了,则让返回用户错误的信息,让用户决定如何去做。
相对于悲观锁,在对数据库进行处理的时候,乐观锁并不会使用数据库提供的锁机制。一般的实现乐观锁的方式就是记录数据版本。
数据版本,为数据增加的一个版本标识。当读取数据时,将版本标识的值一同读出,数据每更新一次,同时对版本标识进行更新。当我们提交更新的时候,判断数据库表对应记录的当前版本信息与第一次取出来的版本标识进行比对,如果数据库表当前版本号与第一次取出来的版本标识值相等,则予以更新,否则认为是过期数据。
实现数据版本有两种方式,第一种是使用版本号,第二种是使用时间戳。
使用版本号实现乐观锁
使用版本号时,可以在数据初始化时指定一个版本号,每次对数据的更新操作都对版本号执行+1操作。并判断当前版本号是不是该数据的最新的版本号。
1.查询出商品信息
select (status,status,version) from t_goods where id=#{id}
2.根据商品信息生成订单
3.修改商品status为2
update t_goods
set status=2,version=version+1
where id=#{id} and version=#{version};
优点与不足
乐观并发控制相信事务之间的数据竞争(data race)的概率是比较小的,因此尽可能直接做下去,直到提交的时候才去锁定,所以不会产生任何锁和死锁。但如果直接简单这么做,还是有可能会遇到不可预期的结果,例如两个事务都读取了数据库的某一行,经过修改以后写回数据库,这时就遇到了问题。
不论是数据库系统本身的锁机制,还是乐观锁这种业务数据级别上的锁机制,本质上都是对状态位的读、写、判断。