业务逻辑的实现过程中,往往需要保证数据访问的排他性。因此,我们就需要通过一些机制来保证这些数据在某个操作过程中不会被外界修改,这样的机制,在这里,也就是所谓的“锁”,即给我们选定的目标数据上锁,使其无法被其它程序修改。

Hibernate 支持两种锁机制:

1. 悲观锁(Pessimistic Locking)

从加载对象就开始锁定。修改过程中一直是锁。直到事务commit()提交后再解锁。

session.load(Info.class,"p003",LockOptions.UPGRADE);

public class TestPessimisticLock extends TestCase {
@Test
public void testLock1(){
Session session = null;
try {
session = HibernateUtil.getSession();//开始锁定,下面的testLock2不能执行
session.beginTransaction(); Info data = session.load(Info.class, "p003", LockOptions.UPGRADE);
data.setName("1111111"); session.getTransaction().commit();//执行以后才解锁,这时testLock2才可以执行
}
catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}
finally{
HibernateUtil.closeSession();
}
}
@Test
public void testLock2(){
Session session = null;
try {
session = HibernateUtil.getSession();
session.beginTransaction(); Info data = session.load(Info.class, "p003", LockOptions.UPGRADE);
data.setName("2222222"); session.getTransaction().commit();
}
catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}
finally{
HibernateUtil.closeSession();
}
}
}

2. 乐观锁(Optimistic Locking)

并不是真的锁,是在提交时间进行冲突检测。把里面的内容与刚开始读取的内容对照一下,有问题就抛异常。相对于悲观锁而言,乐观锁机制采取了更加宽松的加锁机制。

悲观锁大多数情况下依靠数据库的锁机制实现,以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销,特别是对长事务而言,这样的开销往往无法承受。乐观锁机制在一定程度上解决了这个问题。乐观锁,大多是基于数据版本(Version)记录机制实现。何谓数据版本?即为数据增加一个版本标识,在基于数据库表的版本解决方案中,一般是通过为数据库表增加一个"version"字段来实现。

乐观锁的工作原理 :

读取出数据时,将此版本号一同读出,之后更新时,对此版本号加一。此时,将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对,如果提交的数据版本号大于数据库表当前版本号,则予以更新,否则认为是过期数据。

配置:

1.在数据库表中加一个字段version

如果是数据库后加的version字段,那么实体类中必须要加上version并生成get、set方法

public class Info implements java.io.Serializable {

    private String code;
private Nation nation;
private String name;
private Boolean sex;
private Date birthday;
private Set families = new HashSet(0);
private Set works = new HashSet(0);
private int version;//实体类中也要有version,并生成getter和setter public int getVersion() {
return version;
} public void setVersion(int version) {
this.version = version;
}

2.在映谢文件中配置<version name="version"> 这里注意version的位置,一定是要放置在id的后面

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!-- Generated 2017-3-11 10:12:32 by Hibernate Tools 5.2.0.CR1 -->
<hibernate-mapping>
<class name="com.itnba.maya.model.Info" table="info" catalog="mydb" optimistic-lock="version">
<cache usage="read-only"/>
<id name="code" type="string">
<column name="Code" length="50" />
<generator class="assigned" />
</id>
<!-- 配置version,位置放在<id></id>下面 -->
<version name="version"></version>
<many-to-one name="nation" class="com.itnba.maya.model.Nation" fetch="select">
<column name="Nation" length="50" />
</many-to-one>
<property name="name" type="string">
<column name="Name" length="50" />
</property>
<property name="sex" type="java.lang.Boolean">
<column name="Sex" />
</property>
<property name="birthday" type="timestamp">
<column name="Birthday" length="19" />
</property>
</class>
</hibernate-mapping>

配置完成后代码不用改变

由乐观锁引发的问题 

当两个不同的事务同时读取到一条数据并进行修改时,这个时候程序就会抛出org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)异常。

这里同样有两种情况

一种是两个不同的事务的情况

@Test
public void testTransation1(){
Session session1 = null;
Session session2 = null;
try{
session1 = HibernateUtil.getSession();
session2 = HibernateUtil.getSession();
Info info1= session1.load(Info.class, "p003");
Info info2 = session2.load(Info.class, "p003");
Transaction tx1 = session1.beginTransaction();
info1.setName("2222222");
tx1.commit();
Transaction tx2 = session2.beginTransaction();
info2.setName("11111111");
tx2.commit();
System.out.println("事务2提交");
}catch(Exception e){
e.printStackTrace();
}finally{
if(session1 != null){
session1.close();
}
if(session2 != null){
session2.close();
}
}
}

事务2提交时发现version的值不一样,这个时候就会抛出org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)异常.

第二种情况是子事务的情况

@Test
public void testTransation2(){
Session session1 = null;
Session session2 = null;
try{
session1 = HibernateUtil.getSession();
session2 = HibernateUtil.getSession();
Info info1= session1.load(Info.class, "p003");
Info info2 = session2.load(Info.class, "p003");
Transaction tx1 = session1.beginTransaction();
Transaction tx2 = session2.beginTransaction();
info2.setName("11111111");
tx2.commit();
info1.setName("2222222");
tx1.commit();
}catch(Exception e){
e.printStackTrace();
}finally{
if(session1 != null){
session1.close();
}
if(session2 != null){
session2.close();
}
}
}

我们发现事物2被包裹在事务1里面,如果Dir被配置为延迟加载(hibnernate默认就是延迟加载的)的,这个时候在事务1进行提交的时候,会先去数据库进行查询一下,再进行更新操作。

如果Dir被配置为非延迟加载(lazy="false")的,这个时候事务1在提交的时候就不会先去查询数据库,而是直接提交,在提交的时候发现version不匹配,因而也会抛出org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)异常 .

解决办法

1、捕获StaleObjectStateException异常,提示数据过时已被修改,让用户重新提交

2、尽量从业务方面去减小事务块,事务块越大,由乐观锁引起的问题的概率就越大

hibernate悲观锁,乐观锁的更多相关文章

  1. Hibernate悲观锁/乐观锁

    如果需要保证数据访问的排它性,则需对目标数据加"锁",使其无法被其它程序修改 一,悲观锁 对数据被外界(包括本系统当前的其它事务和来自外部系统的事务处理)修改持保守态度,通过数据库 ...

  2. Java并发 行级锁/字段锁/表级锁 乐观锁/悲观锁 共享锁/排他锁 死锁

    原文地址:https://my.oschina.net/oosc/blog/1620279 前言 锁是防止在两个事务操作同一个数据源(表或行)时交互破坏数据的一种机制. 数据库采用封锁技术保证并发操作 ...

  3. Optimistic concurrency control 死锁 悲观锁 乐观锁 自旋锁

    Optimistic concurrency control https://en.wikipedia.org/wiki/Optimistic_concurrency_control Optimist ...

  4. SQL Server 锁机制 悲观锁 乐观锁 实测解析

    先引入一些概念,直接Copy其他Blogs中的,我就不单独写了. 一.为什么会有锁 多个用户同时对数据库的并发操作时会带来以下数据不一致的问题: 1.丢失更新 A,B两个用户读同一数据并进行修改,其中 ...

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

    在Java并发场景中,会涉及到各种各样的锁如公平锁,乐观锁,悲观锁等等,这篇文章介绍各种锁的分类: 公平锁/非公平锁 可重入锁 独享锁/共享锁 乐观锁/悲观锁 分段锁 自旋锁 01.乐观锁 vs 悲观 ...

  6. Java最全锁剖析:独享锁/共享锁+公平锁/非公平锁+乐观锁/悲观锁

    乐观锁 VS 悲观锁 乐观锁与悲观锁是一种广义上的概念,体现了看待线程同步的不同角度,在Java和数据库中都有此概念对应的实际应用. 1.乐观锁 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会 ...

  7. Hibernate 悲观锁,乐观锁

    业务逻辑的实现过程中,往往需要保证数据访问的排他性.因此,我们就需要通过一些机制来保证这些数据在某个操作过程中不会被外界修改,这样的机制,在这里,也就是所谓的“锁”,即给我们选定的目标数据上锁,使其无 ...

  8. hibernate 悲观锁乐观锁

    悲观锁和乐观锁是:在事务隔离机制中设置了ReadCommited的情况下,两种可以避免不可重复读的方式.   设置成读已提交是考虑到安全和处理速度,保证并发效率,但是在这个情况下仍然需要避免不可重复读 ...

  9. 【MySQL】悲观锁&乐观锁

    悲观锁与乐观锁是两种常见的资源并发锁设计思路,也是并发编程中一个非常基础的概念.本文将对这两种常见的锁机制在数据库数据上的实现进行比较系统的介绍. 悲观锁(Pessimistic Lock) 悲观锁的 ...

  10. innodb 悲观锁,乐观锁

    转 http://www.cnblogs.com/chenwenbiao/archive/2012/06/06/2537508.html CREATE TABLE `products` ( `id` ...

随机推荐

  1. BZOJ 3992: [SDOI2015]序列统计 NTT+快速幂

    3992: [SDOI2015]序列统计 Time Limit: 30 Sec  Memory Limit: 128 MBSubmit: 1155  Solved: 532[Submit][Statu ...

  2. BestCoder Round #56 1002 Clarke and problem 1003 Clarke and puzzle (dp,二维bit或线段树)

    今天第二次做BC,不习惯hdu的oj,CE过2次... 1002 Clarke and problem 和Codeforces Round #319 (Div. 2) B Modulo Sum思路差不 ...

  3. coredata 关系的删除规则

    http://blog.csdn.net/Hello_Hwc/article/details/46375517 关系的删除规则-Delete Rule Deny 关系的destination中只要有一 ...

  4. CentOS配置主机名和主机映射

    1.修改本机主机名 vi /etc/sysconfig/network 修改hostname HOSTNAME=s0 2.配置主机映射 vi /etc/hosts 修改内容如下 192.168.32. ...

  5. volatile引发的一系列血案

    最早读<深入理解java虚拟机>对于volatile部分就没有读明白,最近重新拿来研究并记录一些理解 理解volatile前需要把以下这些概念或内容理解: 1.JMM内存模型 2.并发编程 ...

  6. 树莓派 - 修改pi账号密码,开启root账号

    1.修改PI账号的密码 password pi 2.开启root账号 树莓派使用的Linux是debian系统,所以树莓派启用root和debian是相同的. debian里root账户默认没有密码, ...

  7. kubernetes-深入理解pod对象(七)

    Pod中如何管理多个容器 Pod中可以同时运行多个进程(作为容器运行)协同工作.同一个Pod中的容器会自动的分配到同一个 node 上.同一个Pod中的容器共享资源.网络环境和依赖,它们总是被同时调度 ...

  8. DROP OPERATOR - 删除一个操作符

    SYNOPSIS DROP OPERATOR name ( lefttype | NONE , righttype | NONE ) [ CASCADE | RESTRICT ] DESCRIPTIO ...

  9. spring mvc + freemarker 整合

    <?xml version="1.0" encoding="UTF-8" ?> <beans xmlns="http://www.s ...

  10. Hexo + Github Pages搭建的个人博客

    这个不算是新手的搭建流程,如果你恰巧看见这篇文章,希望你已经安装好node.git等软件,因为第一步的环境搭建准备并没有详写,默认都会了.希望能解决你的问题. 步骤: 一. 搭建环境准备 二.安装he ...