- 浏览: 514960 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (563)
- 工作经验 (12)
- 数据库 (13)
- Servlet (10)
- Struts2 (1)
- Spring (25)
- Eclipse (5)
- Hibernate (5)
- Eclips (8)
- HTTP (7)
- J2EE (21)
- EHcache (1)
- HTML (11)
- 工具插件使用 (20)
- JPA (2)
- 杂谈 (17)
- 数据结构与算法 (3)
- Cloud Foundry (1)
- 安全 (10)
- J2SE (57)
- SQL (9)
- DB2 (6)
- 操作系统 (2)
- 设计模式 (1)
- 版本代码管理工具 (13)
- 面试 (10)
- 代码规范 (3)
- Tomcat (12)
- Ajax (5)
- 异常总结 (11)
- REST (2)
- 云 (2)
- RMI (3)
- SOA (1)
- Oracle (12)
- Javascript (20)
- jquery (7)
- JSP自定义标签 (2)
- 电脑知识 (5)
- 浏览器 (3)
- 正则表达式 (3)
- 建站解决问题 (38)
- 数据库设计 (3)
- git (16)
- log4j (1)
- 每天100行代码 (1)
- socket (0)
- java设计模式 耿祥义著 (0)
- Maven (14)
- ibatis (7)
- bug整理 (2)
- 邮件服务器 (8)
- Linux (32)
- TCP/IP协议 (5)
- java多线程并发 (7)
- IO (1)
- 网页小工具 (2)
- Flash (2)
- 爬虫 (1)
- CSS (6)
- JSON (1)
- 触发器 (1)
- java并发 (12)
- ajaxfileupload (1)
- js验证 (1)
- discuz (2)
- Mysql (14)
- jvm (2)
- MyBatis (10)
- POI (1)
- 金融 (1)
- VMWare (0)
- Redis (4)
- 性能测试 (2)
- PostgreSQL (1)
- 分布式 (2)
- Easy UI (1)
- C (1)
- 加密 (6)
- Node.js (1)
- 事务 (2)
- zookeeper (3)
- Spring MVC (2)
- 动态代理 (3)
- 日志 (2)
- 微信公众号 (2)
- IDEA (1)
- 保存他人遇到的问题 (1)
- webservice (11)
- memcached (3)
- nginx (6)
- 抓包 (1)
- java规范 (1)
- dubbo (3)
- xwiki (1)
- quartz (2)
- 数字证书 (1)
- spi (1)
- 学习编程 (6)
- dom4j (1)
- 计算机系统知识 (2)
- JAVA系统知识 (1)
- rpcf (1)
- 单元测试 (2)
- php (1)
- 内存泄漏cpu100%outofmemery (5)
- zero_copy (2)
- mac (3)
- hive (3)
- 分享资料整理 (0)
- 计算机网络 (1)
- 编写操作系统 (1)
- springboot (1)
最新评论
-
masuweng:
亦论一次OutOfMemoryError的定位与解错 -
变脸小伙:
引用[color=red][/color]百度推广中运用的技术 ...
Spring 3 mvc中返回pdf,json,xml等不同的view -
Vanillva:
不同之处是什么??
Mybatis中的like查询 -
thrillerzw:
转了。做个有理想的程序员
有理想的程序员必须知道的15件事 -
liujunhui1988:
觉得很有概括力
15 个必须知道的 Java 面试问题(2年工作经验)
源:http://www.blogjava.net/baoyaer/articles/203445.html
评:
Hibernate支持两种锁机制:
即通常所说的“悲观锁(Pessimistic Locking)”和 “乐观锁(OptimisticLocking)”。
悲观锁的实现,往往依靠数据库提供的锁机制(也只有数据库层提供的锁机制才能真正保证数据访问的排他性,否则,即使在本系统中实现了加锁机制,也无法保证外部系统不会修改数据)。
Hibernate的加锁模式有:
Ø LockMode.NONE : 无锁机制。
Ø LockMode.WRITE :Hibernate在Insert和Update记录的时候会自动
获取。
Ø LockMode.READ : Hibernate在读取记录的时候会自动获取。
以上这三种锁机制一般由Hibernate内部使用,如Hibernate为了保证Update
过程中对象不会被外界修改,会在save方法实现中自动为目标对象加上WRITE锁。
Ø LockMode.UPGRADE :利用数据库的for update子句加锁。
Ø LockMode. UPGRADE_NOWAIT :Oracle的特定实现,利用Oracle的for update nowait子句实现加锁。
Hibernate的悲观锁,也是基于数据库的锁机制实现。 下面的代码实现了对查询记录的加锁:
1 String hqlStr = " from TUser as user where user.name=’Erica’ " ;
2 Query query = session.createQuery(hqlStr);
3 query.setLockMode( " user " ,LockMode.UPGRADE); // 加锁
4 List userList = query.list(); // 执行查询,
获取数据 query.setLockMode 对查询语句中特定别名所对应的记录进行加锁(我们为 TUser类指定了一个别名“user”),这里也就是对返回的所有user记录进行加锁。 观察运行期Hibernate生成的SQL语句:
1 select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex from t_user tuser0_ where (tuser0_.name = ’Erica’ ) for update
这里Hibernate通过使用数据库的for update子句实现了悲观锁机制。
上面这两种锁机制是我们在应用层较为常用的,加锁一般通过以下方法实现:
Criteria.setLockMode
Query.setLockMode
Session.lock
注意,只有在查询开始之前(也就是Hiberate 生成SQL 之前)设定加锁,才会 真正通过数据库的锁机制进行加锁处理,否则,数据已经通过不包含for update 子句的Select SQL加载进来,所谓数据库加锁也就无从谈起。
乐观锁,大多是基于数据版本(Version)记录机制实现。何谓数据版本?即为数据增加一个版本标识,在基于数据库表的版本解决方案中,一般是通过为数据库表增加一个“version”字段来实现。读取出数据时,将此版本号一同读出,之后更新时,对此版本号加一。此时,将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对,如果提交的数据版本号大于数据库表当前版本号,则予以更新,否则认为是过期数据。
1. 首先为TUser的class描述符添加optimistic-lock属性:
< hibernate - mapping >
< class
name = " org.hibernate.sample.TUser "
table = " t_user "
dynamic - update = " true "
dynamic - insert = " true "
optimistic - lock = " version "
>
……
</ class >
</ hibernate - mapping >
添加一个Version属性描述符
代码内容
1 < hibernate - mapping >
2 < class
3 name = " org.hibernate.sample.TUser "
4 table = " t_user "
5 dynamic - update = " true "
6 dynamic - insert = " true "
7 optimistic - lock = " version "
8 >
9 < id
10 name = " id "
11 column = " id "
12 type = " java.lang.Integer "
13 >
14 < generator class = " native " >
15 </ generator >
16 </ id >
17 < version
18 column = " version "
19 name = " version "
20 type = " java.lang.Integer "
21 />
22 ……
23 </ class >
24 </ hibernate - mapping >
25
注意version 节点必须出现在ID 节点之后。
这里我们声明了一个version属性,用于存放用户的版本信息,保存在TUser表的 version字段中。 此时如果我们尝试编写一段代码,更新TUser表中记录数据,如:
代码内容
1 Criteria criteria = session.createCriteria(TUser. class );
2 criteria.add(Expression.eq( " name " , " Erica " ));
3 List userList = criteria.list();
4 TUser user = (TUser)userList.get( 0 );
5 Transaction tx = session.beginTransaction();
6 user.setUserType( 1 ); // 更新UserType字段
7 tx.commit();
8
每次对TUser进行更新的时候,我们可以发现,数据库中的version都在递增。 而如果我们尝试在tx.commit 之前,启动另外一个Session,对名为Erica 的用 户进行操作,以模拟并发更新时的情形:
代码内容
1 Session session = getSession();
2 Criteria criteria = session.createCriteria(TUser. class );
3 criteria.add(Expression.eq( " name " , " Erica " ));
4 Session session2 = getSession();
5 Criteria criteria2 = session2.createCriteria(TUser. class );
6 criteria2.add(Expression.eq( " name " , " Erica " ));
7 List userList = criteria.list();
8 List userList2 = criteria2.list();TUser user = (TUser)userList.get( 0 );
9 TUser user2 = (TUser)userList2.get( 0 );
10 Transaction tx = session.beginTransaction();
11 Transaction tx2 = session2.beginTransaction();
12 user2.setUserType( 99 );
13 tx2.commit();
14 user.setUserType( 1 );
15 tx.commit();
16
执行以上代码,代码将在tx.commit()处抛出StaleObjectStateException异 常,并指出版本检查失败,当前事务正在试图提交一个过期数据。通过捕捉这个异常,我 们就可以在乐观锁校验失败时进行相应处理。
悲观锁与乐观锁的比较:
悲观锁大多数情况下依靠数据库的锁机制实现,以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销,特别是对长事务而言,这样的开销往往无法承受;
相对悲观锁而言,乐观锁机制采取了更加宽松的加锁机制。乐观锁机制往往基于系统中的数据存储逻辑,因此也具备一定的局限性,如在上例中,由于乐观锁机制是在我们的系统中实现,来自外部系统的更新操作不受我们系统的控制,因此可能会造成脏数据被更新到数据库中。在
系统设计阶段,我们应该充分考虑到这些情况出现的可能性,并进行相应调整(如将乐观锁策略在数据库存储过程中实现,对外只开放基于此存储过程的数据更新途径,而不是将数据库表直接对外公开)。
Hibernate 在其数据访问引擎中内置了乐观锁实现。如果不用考虑外部系统对数据库的更新操作,利用Hibernate提供的透明化乐观锁实现,将大大提升我们的生产力。
Hibernate中可以通过class描述符的optimistic-lock属性结合version描述符指定。
optimistic-lock属性有如下可选取值:
Ø none
无乐观锁
Ø version
通过版本机制实现乐观锁
Ø dirty
通过检查发生变动过的属性实现乐观锁
Ø all
通过检查所有属性实现乐观锁
其中通过version实现的乐观锁机制是Hibernate官方推荐的乐观锁实现,同时也是Hibernate中,目前唯一在数据对象脱离Session发生修改的情况下依然有效的锁机制。因此,一般情况下,我们都选择version方式作为Hibernate乐观锁实现机制。
评:
Hibernate支持两种锁机制:
即通常所说的“悲观锁(Pessimistic Locking)”和 “乐观锁(OptimisticLocking)”。
悲观锁的实现,往往依靠数据库提供的锁机制(也只有数据库层提供的锁机制才能真正保证数据访问的排他性,否则,即使在本系统中实现了加锁机制,也无法保证外部系统不会修改数据)。
Hibernate的加锁模式有:
Ø LockMode.NONE : 无锁机制。
Ø LockMode.WRITE :Hibernate在Insert和Update记录的时候会自动
获取。
Ø LockMode.READ : Hibernate在读取记录的时候会自动获取。
以上这三种锁机制一般由Hibernate内部使用,如Hibernate为了保证Update
过程中对象不会被外界修改,会在save方法实现中自动为目标对象加上WRITE锁。
Ø LockMode.UPGRADE :利用数据库的for update子句加锁。
Ø LockMode. UPGRADE_NOWAIT :Oracle的特定实现,利用Oracle的for update nowait子句实现加锁。
Hibernate的悲观锁,也是基于数据库的锁机制实现。 下面的代码实现了对查询记录的加锁:
1 String hqlStr = " from TUser as user where user.name=’Erica’ " ;
2 Query query = session.createQuery(hqlStr);
3 query.setLockMode( " user " ,LockMode.UPGRADE); // 加锁
4 List userList = query.list(); // 执行查询,
获取数据 query.setLockMode 对查询语句中特定别名所对应的记录进行加锁(我们为 TUser类指定了一个别名“user”),这里也就是对返回的所有user记录进行加锁。 观察运行期Hibernate生成的SQL语句:
1 select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex from t_user tuser0_ where (tuser0_.name = ’Erica’ ) for update
这里Hibernate通过使用数据库的for update子句实现了悲观锁机制。
上面这两种锁机制是我们在应用层较为常用的,加锁一般通过以下方法实现:
Criteria.setLockMode
Query.setLockMode
Session.lock
注意,只有在查询开始之前(也就是Hiberate 生成SQL 之前)设定加锁,才会 真正通过数据库的锁机制进行加锁处理,否则,数据已经通过不包含for update 子句的Select SQL加载进来,所谓数据库加锁也就无从谈起。
乐观锁,大多是基于数据版本(Version)记录机制实现。何谓数据版本?即为数据增加一个版本标识,在基于数据库表的版本解决方案中,一般是通过为数据库表增加一个“version”字段来实现。读取出数据时,将此版本号一同读出,之后更新时,对此版本号加一。此时,将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对,如果提交的数据版本号大于数据库表当前版本号,则予以更新,否则认为是过期数据。
1. 首先为TUser的class描述符添加optimistic-lock属性:
< hibernate - mapping >
< class
name = " org.hibernate.sample.TUser "
table = " t_user "
dynamic - update = " true "
dynamic - insert = " true "
optimistic - lock = " version "
>
……
</ class >
</ hibernate - mapping >
添加一个Version属性描述符
代码内容
1 < hibernate - mapping >
2 < class
3 name = " org.hibernate.sample.TUser "
4 table = " t_user "
5 dynamic - update = " true "
6 dynamic - insert = " true "
7 optimistic - lock = " version "
8 >
9 < id
10 name = " id "
11 column = " id "
12 type = " java.lang.Integer "
13 >
14 < generator class = " native " >
15 </ generator >
16 </ id >
17 < version
18 column = " version "
19 name = " version "
20 type = " java.lang.Integer "
21 />
22 ……
23 </ class >
24 </ hibernate - mapping >
25
注意version 节点必须出现在ID 节点之后。
这里我们声明了一个version属性,用于存放用户的版本信息,保存在TUser表的 version字段中。 此时如果我们尝试编写一段代码,更新TUser表中记录数据,如:
代码内容
1 Criteria criteria = session.createCriteria(TUser. class );
2 criteria.add(Expression.eq( " name " , " Erica " ));
3 List userList = criteria.list();
4 TUser user = (TUser)userList.get( 0 );
5 Transaction tx = session.beginTransaction();
6 user.setUserType( 1 ); // 更新UserType字段
7 tx.commit();
8
每次对TUser进行更新的时候,我们可以发现,数据库中的version都在递增。 而如果我们尝试在tx.commit 之前,启动另外一个Session,对名为Erica 的用 户进行操作,以模拟并发更新时的情形:
代码内容
1 Session session = getSession();
2 Criteria criteria = session.createCriteria(TUser. class );
3 criteria.add(Expression.eq( " name " , " Erica " ));
4 Session session2 = getSession();
5 Criteria criteria2 = session2.createCriteria(TUser. class );
6 criteria2.add(Expression.eq( " name " , " Erica " ));
7 List userList = criteria.list();
8 List userList2 = criteria2.list();TUser user = (TUser)userList.get( 0 );
9 TUser user2 = (TUser)userList2.get( 0 );
10 Transaction tx = session.beginTransaction();
11 Transaction tx2 = session2.beginTransaction();
12 user2.setUserType( 99 );
13 tx2.commit();
14 user.setUserType( 1 );
15 tx.commit();
16
执行以上代码,代码将在tx.commit()处抛出StaleObjectStateException异 常,并指出版本检查失败,当前事务正在试图提交一个过期数据。通过捕捉这个异常,我 们就可以在乐观锁校验失败时进行相应处理。
悲观锁与乐观锁的比较:
悲观锁大多数情况下依靠数据库的锁机制实现,以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销,特别是对长事务而言,这样的开销往往无法承受;
相对悲观锁而言,乐观锁机制采取了更加宽松的加锁机制。乐观锁机制往往基于系统中的数据存储逻辑,因此也具备一定的局限性,如在上例中,由于乐观锁机制是在我们的系统中实现,来自外部系统的更新操作不受我们系统的控制,因此可能会造成脏数据被更新到数据库中。在
系统设计阶段,我们应该充分考虑到这些情况出现的可能性,并进行相应调整(如将乐观锁策略在数据库存储过程中实现,对外只开放基于此存储过程的数据更新途径,而不是将数据库表直接对外公开)。
Hibernate 在其数据访问引擎中内置了乐观锁实现。如果不用考虑外部系统对数据库的更新操作,利用Hibernate提供的透明化乐观锁实现,将大大提升我们的生产力。
Hibernate中可以通过class描述符的optimistic-lock属性结合version描述符指定。
optimistic-lock属性有如下可选取值:
Ø none
无乐观锁
Ø version
通过版本机制实现乐观锁
Ø dirty
通过检查发生变动过的属性实现乐观锁
Ø all
通过检查所有属性实现乐观锁
其中通过version实现的乐观锁机制是Hibernate官方推荐的乐观锁实现,同时也是Hibernate中,目前唯一在数据对象脱离Session发生修改的情况下依然有效的锁机制。因此,一般情况下,我们都选择version方式作为Hibernate乐观锁实现机制。
发表评论
-
java并发面试题(二)实战
2015-12-11 13:20 702源:http://ifeve.com/javaconcurre ... -
java并发面试题(一)基础
2015-12-11 13:20 951源:http://ifeve.com/javaconcurre ... -
java守护进程
2014-06-29 16:56 522源:http://blog.sina.com.cn/s/blo ... -
根据HTTP状态代码分析错误信息
2014-05-11 20:04 503源:http://584506509.iteye.com/bl ... -
java的算术右移(>>)与逻辑右移(>>>)
2014-03-04 00:30 808源:http://blog.csdn.net/zgrjkflm ... -
微软面试题
2014-03-04 00:15 798源:http://www.iteye.com/topic/62 ... -
红薯 7 种将字符串反转的 Java 方法
2014-03-02 20:03 520源:http://www.oschina.net/code/s ... -
查找目录下的所有文件中是否含有某个字符串 linux
2014-03-02 17:50 858源:http://blog.chinaunix.net ... -
log4j配置 显示Hibernate的HQL语句参数值
2013-03-14 19:54 1216源:http://peijunlin2008.iteye.c ... -
java面试和笔试大全
2013-03-12 11:05 726源:http://www.cnblogs.com/ ... -
Hibernate get和load区别
2013-02-25 09:06 708源:http://www.cnblogs.com/b ... -
hibernate性能对比文章
2013-01-17 09:20 1293源:http://daquan198163.ite ... -
HibernaHibernate 自动创建表的方法 ( 自动创建表的方法
2013-01-16 09:38 1289我们从网上搜索到的hibernate源码中很多时候只有vo ...
相关推荐
【Hibernate乐观锁与悲观锁详解】 在开发过程中,尤其是在并发环境下,确保数据的一致性和完整性至关重要。Hibernate,作为Java领域广泛使用的ORM框架,提供了一种处理并发数据访问冲突的手段,那就是锁机制。主要...
### Hibernate的乐观锁与悲观锁 #### 一、引言 在并发环境下,尤其是在金融、电商等业务场景中,确保数据的一致性和完整性至关重要。**Hibernate**作为一种流行的Java持久层框架,提供了多种机制来处理并发控制...
本文主要讨论的是Hibernate框架中两种锁机制的使用:乐观锁和悲观锁。 首先,让我们深入理解悲观锁(Pessimistic Locking)。悲观锁正如其名字所示,假设并发环境中数据会被频繁修改,所以在整个数据处理过程中,它...
在进行Hibernate的测试时,可以创建一个名为`hibernate_test`的项目,编写对应的实体类、映射文件以及测试用例,模拟并发场景,来深入理解并对比悲观锁和乐观锁的差异和效果。 总之,理解并合理运用悲观锁和乐观锁...
### Hibernate的乐观锁和悲观锁 #### 一、引言 在软件开发中,尤其是在涉及大量并发操作的应用场景下,确保数据的一致性和完整性是非常重要的。对于基于Java Web的应用而言,Hibernate作为一款流行的ORM框架,提供...
Hibernate 锁机制_悲观锁和乐观锁 Hibernate 锁机制是指在数据库访问中,为了维护数据的一致性和正确性,所采取的一些机制来防止数据的并发访问和修改。 Hibernate 中有两种锁机制:悲观锁和乐观锁。 一、悲观锁...
总的来说,Hibernate的悲观锁和乐观锁是处理并发问题的重要工具,开发者需要根据实际情况权衡性能和数据一致性,合理选择并使用合适的锁策略。在实际项目中,还可以结合使用其他的并发控制手段,如事务隔离级别、...
《Hibernate 悲观锁与乐观锁详解》 在多用户并发访问的环境中,数据库管理系统必须具备有效的数据访问控制机制,以确保数据的一致性和完整性。Hibernate,作为一款流行的Java持久化框架,提供了两种主要的锁定策略...
Hibernate乐观锁是数据库事务控制的一种策略,主要用于处理并发更新数据的情况。在乐观锁的机制下,假设并发用户很少会发生冲突,所以在读取数据时不会进行任何锁定,而在更新数据时才会检查在此期间是否有其他用户...
6. **文件关联**:压缩包中的文件名称列表看似与主题“Hibernate 乐观和悲观锁”不直接相关,"走出软件作坊:三五个人十来条枪 如何成为开发正规军.chm、走出软件作坊.doc"可能是一些关于软件开发团队建设和成长的...
在Hibernate中,可以使用`@Version`注解来实现乐观锁,该注解会在实体类的一个属性上添加版本字段,每次更新时,Hibernate会比较当前版本号和数据库中的版本号,如果不同,则认为有并发冲突,更新失败。乐观锁的优点...
在Java中,可以使用`@Version`注解配合Hibernate框架来实现乐观锁。 悲观锁则采取相反的策略,它假设数据可能会被其他线程修改,所以在读取数据时就立即加锁,直到事务结束才释放锁。这样可以确保在读取数据到更新...
### Java中的悲观锁与乐观锁实现详解 #### 一、悲观锁(Pessimistic Locking) 悲观锁是一种基于对数据安全性的保守态度而设计的锁机制。它假设数据在处理过程中很可能被外界修改,因此在整个数据处理过程中都会将...
下面是一个使用 Hibernate 实现悲观锁和乐观锁的代码示例: Account.java: ```java package com.bjsxt.hibernate; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax....
求助编辑百科名片相对悲观锁而言,乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现,以保证操作最大程度的独占性。但随之而来的就是数据库 性能的大量开销,特别是对长事务而言,...
为了解决这个问题,Hibernate提供了两种锁机制:乐观锁和悲观锁。下面我们将深入探讨这两个概念以及它们在实际应用中的实践。 ### 乐观锁 乐观锁是一种假设大多数情况下不会发生数据冲突的锁策略。在读取数据时不会...
与悲观锁相比,乐观锁假设在大多数情况下不会发生数据冲突,因此在读取数据时不会加锁,只有在更新数据时才会检查在此期间数据是否被其他事务修改过。 在Hibernate框架中,乐观锁的实现方式之一是通过`version`字段...
乐观锁适用于读多写少的情况,减少锁的使用,提高并发性能。 在实际开发中,开发者应根据业务场景选择合适的锁定策略,并结合缓存和延迟加载技术,以及优化SQL查询,来平衡性能和数据一致性,实现高效的Hibernate...