[转]数据库并发控制 乐观锁,悲观锁

在数据库中,并发控制有乐观锁和悲观锁之间,什么时候用乐观锁比较好什么时候用悲观锁比较好?

实际生产环境里边,如果并发量不大,完全可以使用悲观锁定的方法,这种方法使用起来非常方便和简单。
但是如果系统的并发非常大的话,悲观锁定会带来非常大的性能问题,所以就要选择乐观锁定的方法。

悲观锁假定其他用户企图访问或者改变你正在访问、更改的对象的概率是很高的,因此在悲观锁的环境中,在你开始改变此对象之前就将该对象锁住,并且直到你提交了所作的更改之后才释放锁。悲观的缺陷是不论是页锁还是行锁,加锁的时间可能会很长,这样可能会长时间的限制其他用户的访问,也就是说悲观锁的并发访问性不好。
乐观锁则认为其他用户企图改变你正在更改的对象的概率是很小的,因此乐观锁直到你准备提交所作的更改时才将对象锁住,当你读取以及改变该对象时并不加锁。可见乐观锁加锁的时间要比悲观锁短,乐观锁可以用较大的锁粒度获得较好的并发访问性能。但是如果第二个用户恰好在第一个用户提交更改之前读取了该对象,那么当他完成了自己的更改进行提交时,数据库就会发现该对象已经变化了,这样,第二个用户不得不重新读取该对象并作出更改。这说明在乐观锁环境中,会增加并发用户读取对象的次数。

以版本控制系统为例,来说说两种最基本的并发性问题。
  【丢失更新】
 
小张想修改源代码里面的a方法,正在她修改的同时,小李打开了这个文件,修改了b方法并且保存了文件,等小张修改完成后,保存文件,小李所做的修改就被覆盖了。

  【不一致的读】
 
小张想要知道包里面一共有多少个类,包分了a,b两个子包。小张打开a包,看到了7个类。突然小张接到老婆打来的电话,在小张接电话的时候,小李往a包中加了2个类,b包中加了3个类(原先b包中是5个类)。

  小张接完电话后再打开b包,看到了8个类,很自然得出结论:包中一共有15个类。
 
很遗憾,15个永远不是正确的答案。在小李修改前,正确答案是12(7+5),修改后是17(9+8)。这两个答案都是正确的,虽然有一个不是当前的。但15不对,因为小张读取的数据是不一致的。

  小结:不一致读指你要读取两种数据,这两种数据都是正确的,但是在同一时刻两者并非都正确。
  【隔离 和 不可变】

  在企业应用中,解决并发冲突的两种常用手段是隔离和不可变。
 
只有当多个活动(进程或者线程)同时访问同一数据时才会引发并发问题。一种很自然的思路就是同一时刻只允许一个活动访问数据。如果小张打开了文件,就不允许其他人打开,或者其他人只能通过只读的方式打开副本,就可以解决这个问题。

 
隔离能够有效减少发生错误的可能。我们经常见到程序员陷入到并发问题的泥潭里,每一段代码写完都要考虑并发问题,这样太累了。我们可以利用隔离技术创建出隔离区域,当程序进入隔离区域时不用关心并发问题。好的并发性设计就是创造这样的一些隔离区域,并保证代码尽可能的运行在其中。

 
另一种思路:只有当你需要修改共享的数据时才可能引发并发性问题,所以我们可以将要共享的数据制作为“不可变”的,以避免并发性问题。当然我们不可能将所有的数据都做成不可变的,但如果一些数据是不可变的,对它们进行并发操作时我们就可以放松自己的神经了。

  【乐观并发控制、悲观并发控制】
 
如果数据是可变的,并且无法隔离呢?这种情况下最常用的两种控制就是乐观并发控制和悲观并发控制。
 
假设小张和小李想要同时修改同一个文件。如果使用乐观锁,俩人都能打开文件进行修改,如果小张先提交了内容,没有问题,他所做的改变会保存到服务器上。但小李提交时就会遇到麻烦,版本控制服务器会检测出两种修改的冲突,小李的提交会被具体,并由小李决定该如何处理这种情况(对于绝大部分版本控制软件来说,会读取并标识出小张做的改变,然后由小李决定是否合并)。

  如果使用的是悲观锁,小张先检出(check out)文件,那么小李就无法再次检出同一文件,直到小张提交了他的改变。
 
建议你将乐观锁想成一种检测冲突的手段,而悲观锁是一种避免冲突的手段(严格来说,乐观锁其实不能称之为“锁”,但是这个名字已经流传开了,那就继续使用吧)。一些老的版本控制系统,比如VSS
6.0使用的是悲观锁的机制。而现代的版本控制系统一般两种都支持,默认使用乐观锁。
 
两种锁各有优缺点。。。这段懒的翻译了,很明显看出,乐观锁可以提高并发访问的效率,但是如果出现了冲突只能向上抛出,然后重来一遍;悲观锁可以避免冲突的发生,但是会降低效率。

 
选择使用那一种锁取决于访问频率和一旦产生冲突的严重性。如果系统被并发访问的概率很低,或者冲突发生后的后果不太严重(所谓后果应该指被检测到冲突的提交会失败,必须重来一次),可以使用乐观锁,否则使用悲观锁。

  【我再补充两句】
 
我们经常会在访问数据库的时候用到锁,怎么实现乐观锁和悲观锁呢?以Hibernate为例,可以通过为记录添加版本或时间戳字段来实现乐观锁。可以用session.Lock()锁定对象来实现悲观锁(本质上就是执行了SELECT
* FROM t FOR UPDATE语句)。 

另一个高并发控制解决方案乐观并发控制和悲观并发控制总结概述:

我们可以使用两种形式的并发控制策略:乐观并发控制和悲观并发控制。

假设martin和David同时都要编辑Customer文件。如果使用乐观锁策略,他们两个人都能得到一份文件的Copy,并且

可以自由编辑文件。假设David第一个完成了工作,那么他可以毫无困难地更新他的修改。但是,当Martin想要提交他的修改时,并发控制策略就会开始起作用。源代码控制系统会检测到在Martin的修改与David的修改之间存在着冲突,因而拒绝Martin的提交,并由Martin负责指出怎样处理这种情况。如果使用悲观锁策略,只要有人先取出文件,其他人就不能对该文件进行编辑。因此,假如是Martin先取了文件,那么David就只能在Martin完成任务并提交之后才能对该文件进行操作。

如果把乐观锁看作是关于冲突检测的,那么悲观锁就是关于冲突避免的。在实际应用的源代码控制系统中,

这两种策略都可以被使用,但是现在大多数源代码开发者更倾向于使用乐观锁策略。(有一种很有道理的说法:乐观锁并不是真正的锁定,但是这种叫法很方便并且广泛流传,以至于不容忽略。)

这两种策略各有优缺点。悲观锁的问题是减少了并发的程序。当Martin正对一个被他加锁的文件进行编辑的时候,

其它人只能等着。使用过悲观的源代码控制人都知道这是一种多么令人丧气的事情。对于企业数据,情况经常会变得更加糟糕,只要有人在编辑,其他人就无法进行读取,更加说进行编辑了。

乐观锁策略则允许人们更自由一些,因为只有在提交的时候才有可能遇到阻碍。该策略的问题在于当冲突的时候会发生什么样的事情呢?事实上,David之后的所有人在提交的时候都必须读取David修改过的那个版本,并指出怎样合并自己和David的修改,然后再提交一个重新修改过的最新版本。有了源代码控制系统,这样做并不会有什么麻烦。在许多场合下,源代码控制系统确实能够自动进行合并操作,甚至在无法自动合并的时候,也能让使用都很容易看出不同文件版本之间的差别。但是,业务数据通常都是很难被自动合并的,所以经常只能扔掉原来的东西,然后从头开始。

在乐观锁和悲观锁之间进行选择的标准是:冲突的频率与严重性。如果冲突很少,或者冲突的后果不会很严重,那么通常情况下应该选择乐观锁,因为它能得到更好的并发性,而且更容易实现。但是,如果冲突的结果对于用户来说痛苦的,那么就需要使用悲观策略。

乐观锁的局限是:只能在提交数据时才发现业务事务将要失败,而且在某些情况下,发现失败太迟的代价会很大。用户可能花了一个小时的时间输入一份租约的详细信息,错误太多会让用户对系统失去信心。另一个方法是使用悲观锁,它可以尽早地发现错误,但理难以编程实现,而且会降低系统的灵活性。

(注:以上是对并发控制中的乐观锁策略和悲观锁策略概念及解决思路的文字描述,下面我将对项目中具体怎么实现乐观锁策略及悲观锁策略进行描述。)

乐观锁策略实现方法:

    就是用C#中或SQL中的事务来实现数据操作不成功就回滚,个人感觉火车站卖票系统也是这样操作的,我们看到显示屏上有少量剩余票,但我们去买又打不出来。

悲观锁策略实现方法:

1、普通的aspx页面,当用户点提交后,直接将提交及相关按钮的enabel改为false,直到提交事件完成后,再改回来。另外在数据层那一块,每次提交数据更改时,都需要判断数据以前的状态是否改变,以防止有并发改变的情况出现。

2、jquery中,在jquery中,可以设置一个全局变量,提交时,先判断全局变量状态,如不允许提交则直接返回,如允许提交时,则先将全局变量置为“不允许提交”,后开始提交,提交完成后,在jquery的post方法的callback方法中,再将全局变量改为“允许提交”。

3、弹出式窗口修改页面,则用模态方式弹出,如web页面中,可用window.showModalDialog()来实现模态方式打开修改页面,来确保始终只有一个修改页面被打开。(这是从数据操作页面处就悲观锁定了数据,而不是在数据库里面悲观锁定)

http://msdn.microsoft.com/zh-cn/library/ms189132.aspx

http://msdn.microsoft.com/zh-cn/library/ms189122.aspx

http://msdn.microsoft.com/zh-cn/library/ms173763.aspx

[转]数据库并发控制 乐观锁,悲观锁,布布扣,bubuko.com

时间: 2024-10-08 16:33:41

[转]数据库并发控制 乐观锁,悲观锁的相关文章

最全Java锁详解:独享锁/共享锁+公平锁/非公平锁+乐观锁/悲观锁

在Java并发场景中,会涉及到各种各样的锁如公平锁,乐观锁,悲观锁等等,这篇文章介绍各种锁的分类: 公平锁/非公平锁 可重入锁 独享锁/共享锁 乐观锁/悲观锁 分段锁 自旋锁 01.乐观锁 vs 悲观锁 乐观锁与悲观锁是一种广义上的概念,体现了看待线程同步的不同角度,在Java和数据库中都有此概念对应的实际应用. 1.乐观锁 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制. 乐观锁适用于多

【多线程】公平锁/非公平锁、乐观锁/悲观锁

公平锁/非公平锁(多线程执行顺序的维度) 概念理解 公平锁:加锁前先查看是否有排队等待的线程,有的话优先处理排在前面的线程,先来先得. 非公平所:线程加锁时直接尝试获取锁,获取不到就自动到队尾等待. 例子 ReentrantLock 同时支持两种锁 //创建一个非公平锁,默认是非公平锁 Lock nonFairLock= new ReentrantLock(); Lock nonFairLock= new ReentrantLock(false); //创建一个公平锁,构造传参true Lock

AtomicInteger如何保证线程安全以及乐观锁/悲观锁的概念

众所周知,JDK提供了AtomicInteger保证对数字的操作是线程安全的,线程安全我首先想到了synchronized和Lock,但是这种方式又有一个名字,叫做互斥锁,一次只能有一个持有锁的线程进入,再加上还有不同线程争夺锁这个机制,效率比较低,所以又称“悲观锁”. 但是相应的有了乐观锁的概念,他的思路就是,它不加锁去完成某项操作,如果因为冲突失败就重试,直到成功为止.这种说的比较抽象,我们直接拿AtomicInteger源码举例,因为AtomicInteger保证线程安全就是因为使用了乐观

并发控制:(二)乐观锁 悲观锁

悲观锁:(pessimistic locking):假定:发生冲突的概率比较高,实现:在对任意记录进行修改前,先尝试为该记录加上排他锁(exclusive locking).这样其他事务如果想操作该记录,需要等待锁的释放特点: 当并发量较大,频繁访问时,等待时间较长,并发访问性不好例如: java的synchronized,SqlServer页级锁,Oracle行级锁 乐观锁:(optimistic locking)假设:发生冲突的概率比较低实现:在提交对记录的更改时才将对象锁住,提交前需要检查

解决并发问题,数据库常用的两把锁——悲观锁,乐观锁

一.概念: 乐观锁:适用于写少读多的情景,因为这种乐观锁相当于java的cas(比较并替换),所以多条数据同事过来的时候不用等待,可以立即进行返回 悲观锁:适用于写多读少的情景,这种情况也相当于java的synchronized,reentrantLock等,大量数据过来的时候,只有一条被写入,其他数据需要等待,智行完成后下一条数据继续. 二:实现方式: 乐观锁:采用版本号的方式.即当前版本号如果对应上了就可以写入数据,如果判断当前版本号不一致,那么就不会更新成功. 比如 update tabl

数据库中常用的悲观锁和乐观锁

悲观锁:指悲观的认为数据存在脏读.超卖的场景.就会把大量访问锁死.悲观锁 分为 文件锁 和 数据表所  数据表锁又分为 表锁和行锁 ,表锁 是锁着这个表 只让只让他访问,其他都访问不了.而行锁 是针对某一条访问数据,进行的锁定.假如 同时有一万个用户来访问这个商品,但是他只有十个商品数量,此时,如果都同时购买就使库存不够,这时候就需要使用,行锁,只让某一个线程购买,其他访问线程就是搁置着,这个时候就会使访问网站瘫痪的可能. 乐观锁:就是使用redis,同时有一万个用户访问,乐观的认为不会存在冲突

Mysql:行锁 表锁 乐观锁 悲观锁 读锁 写锁

锁是在执行多线程时用于强行限制资源访问的同步机制,即用于在并发控制中保证对互斥要求的满足.在DBMS中,可以按照锁的粒度把数据库锁分为行级锁(INNODB引擎).表级锁(MYISAM引擎)和页级锁(BDB引擎 ). 行锁 锁定整个行数据,开销大,加锁慢,会出现死锁.锁定粒度小,发生锁冲突的概率低,并发度高. 表锁 锁定整个表数据,开销小,加锁快,不会出现死锁.锁定粒度大,发生锁冲突概率高,并发度低. 悲观锁 每次取数据时都认为别人会修改,所以每次取数据的时候都会上锁,这样别人想拿这个数据就会被阻

Mysql锁机制--乐观锁 & 悲观锁

前言 mysql的并发操作时而引起的数据的不一致性(数据冲突): 丢失更新:两个用户(或以上)对同一个数据对象操作引起的数据丢失. 解决方案:1.悲观锁,假设丢失更新一定存在:sql后面加上for update:这是数据库的一种机制. 2.乐观锁,假设丢失更新不一定发生.update时候存在版本,更新时候按版本号进行更新. 第一部分 悲观锁 1 概念 悲观锁,正如其名,它指的是对数据被外界(包括当前系统的其它事务,以及来自外部系统的事务处理)修改持保守态度,因此,在整个数据处理过程中,将数据处于

乐观锁悲观锁

老生常谈,这个写的挺好. http://blog.csdn.net/hongchangfirst/article/details/26004335 悲观锁(Pessimistic Lock), 顾名思义,就是很悲观,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会block直到它拿到锁.传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁. 乐观锁(Optimistic Lock), 顾名思义,就是很乐观