Hibernate悲观锁/乐观锁

最新推荐文章于 2022-01-02 10:00:00 发布
最新推荐文章于 2022-01-02 10:00:00 发布
阅读量280 收藏 1
点赞数
文章标签： java 数据库
原文链接：http://www.cnblogs.com/sean-zou/p/3709975.html
版权

如果需要保证数据访问的排它性，则需对目标数据加“锁”，使其无法被其它程序修改

一，悲观锁

对数据被外界（包括本系统当前的其它事务和来自外部系统的事务处理）修改持保守态度，通过数据库提供的锁机制实现

最常用的，是对查询进行加锁（LockMode.UPGRADE和LockMode.UPGRADE_NOWAIT）：

public class Test {
	public static void main(String[] args) {
		Configuration conf = new Configuration();  
        SessionFactory sessionFactory = conf.configure().buildSessionFactory(); 
        
        Session sess = sessionFactory.openSession();
        Transaction tran = sess.beginTransaction();
        
        String hql = "from User where id = 1";
        Query query = sess.createQuery(hql);
        query.setLockOptions(LockOptions.UPGRADE);
        List<User> list = query.list();
        for(User user : list){
        	System.out.print(user.getName()+" ");
        }
        System.out.println();

        tran.commit();
        
        sess.close(); 
	}
}

Hibernate会在生成的SQL后面加上for update子句：

Hibernate: select user0_.id as id0_, user0_.name as name0_, user0_.age as age0_ 
		from TEST_USER user0_ where user0_.id=1 for update
longlong

通过for update子句，这条SQL锁定了TEST_USER表中符合检索条件的记录，本次事务提交前，外界无法修改这些记录，事务提交时会释放事务过程中的锁

Hibernate提供了2个锁对象，LockMode和LockOptions：

通过LockOptions的源代码，可以发现LockOptions只是LockMode的简单封装（在LockMode的基础上提供了timeout和scope）：

......
/**
 * NONE represents LockMode.NONE (timeout + scope do not apply)
 */
public static final LockOptions NONE = new LockOptions(LockMode.NONE);

/**
 * READ represents LockMode.READ (timeout + scope do not apply)
 */
public static final LockOptions READ = new LockOptions(LockMode.READ);

/**
 * UPGRADE represents LockMode.UPGRADE (will wait forever for lock and
 * scope of false meaning only entity is locked)
 */
public static final LockOptions UPGRADE = new LockOptions(LockMode.UPGRADE);

public LockOptions(){}

public LockOptions( LockMode lockMode) {
	this.lockMode = lockMode;
}
.....
public static final int NO_WAIT = 0;

/**
 * Indicates that there is no timeout for the acquisition.
 * @see #getTimeOut
 */
public static final int WAIT_FOREVER = -1;

private int timeout = WAIT_FOREVER;

private boolean scope=false;
......

LockOptions提供的加锁机制要比LockMode少很多，但是LockMode多出的加锁机制一般只是供Hibernate内部实现使用的

保证了操作的独占性，但严重影响数据库性能


二，乐观锁

乐观锁大多基于数据版本记录机制实现，既为数据增加一个版本标识

在数据库中增加version列，用来记录每行数据的版本

Hibernate配置文件中，version节点需要在id节点之后并紧跟id节点

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
		"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping>
    <class name="com.po.User" 
        table="TEST_USER">
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="assigned"/>
        </id>
        <version name="version"
        		column="version"
        		type="java.lang.Integer"/>
        <property name="name"
				column="name"
            	type="java.lang.String"
            	not-null="true"
           	 	unique="true"
            	length="20"/>
        <property name="age"
            	column="age"
            	type="java.lang.Integer"
            	not-null="true"
            	unique="false"
            	length="0"/>
    </class>
</hibernate-mapping>

每次更新User对象时时，对应行的version字段都在增加

public class Test {
	public static void main(String[] args) {
		Configuration conf = new Configuration();  
        SessionFactory sessionFactory = conf.configure().buildSessionFactory();
        
        Session sess1=sessionFactory.openSession();
        Session sess2=sessionFactory.openSession();
		try{
	        User user1 = (User)sess1.get(User.class, 1);
	        User user2 = (User)sess2.get(User.class, 1);
	  
	        System.out.println("v1="+user1.getVersion()+"--v2="+user2.getVersion());
	        
	        Transaction tx1 = sess1.beginTransaction();
	        Transaction tx2 = sess2.beginTransaction();
	        
	        user1.setName("ll");
	        tx1.commit();
	        
	        System.out.println("v1="+user1.getVersion()+"--v2="+user2.getVersion());
	        
	        user2.setName("LL");
	        tx2.commit();
		}catch(Exception e){
			e.printStackTrace();
		}finally{
	        sess1.close();
	        sess2.close();
		}
	}
}

运行结果如下，可以看到由于tx1提交时，version字段已经被修改，tx2提交时会抛出异常：

Hibernate: select user0_.id as id0_0_, user0_.version as version0_0_, user0_.name as name0_0_, user0_.age as age0_0_ 
		from TEST_USER user0_ where user0_.id=?
Hibernate: select user0_.id as id0_0_, user0_.version as version0_0_, user0_.name as name0_0_, user0_.age as age0_0_ 
		from TEST_USER user0_ where user0_.id=?
v1=0--v2=0
Hibernate: update TEST_USER set version=?, name=?, age=? where id=? and version=?
v1=1--v2=0
Hibernate: update TEST_USER set version=?, name=?, age=? where id=? and version=?
Exception in thread "main" org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction 
		(or unsaved-value mapping was incorrect): [com.po.User#1]
	at org.hibernate.persister.entity.AbstractEntityPersister.check(AbstractEntityPersister.java:1932)
	at org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:2576)
	at org.hibernate.persister.entity.AbstractEntityPersister.updateOrInsert(AbstractEntityPersister.java:2476)
	at org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:2803)
	at org.hibernate.action.EntityUpdateAction.execute(EntityUpdateAction.java:113)
	at org.hibernate.engine.ActionQueue.execute(ActionQueue.java:273)
	at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:265)
	at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:185)
	at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321)
	at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:51)
	at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1216)
	at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:383)
	at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:133)
	at com.test.Test.main(Test.java:43)

除了使用version作为版本标识，还可以使用timestamp作为版本标识

timestamp节点没有type属性：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
		"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping>
    <class name="com.po.User" 
        table="TEST_USER">
        <id name="id" column="id" type="java.lang.Integer">
            <generator class="assigned"/>
        </id>
        <timestamp name="updatetime"
        		column="updatetime"/>
        <property name="name"
				column="name"
            	type="java.lang.String"
            	not-null="true"
           	 	unique="true"
            	length="20"/>
        <property name="age"
            	column="age"
            	type="java.lang.Integer"
            	not-null="true"
            	unique="false"
            	length="0"/>
    </class>
</hibernate-mapping>

在某些情况下，不允许修改数据库的表结构，此时Hibernate也有相应的处理手段：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
		"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >

<hibernate-mapping>
    <class name="com.po.User" 
    		table="TEST_USER"
        	optimistic-lock="all"
        	dynamic-update="true"
        	dynamic-insert="true"
        	>
        <id name="id" column="id" type="java.lang.Integer">
        	<generator class="assigned"/>
        </id>
        <property name="name"
				column="name"
            	type="java.lang.String"
            	not-null="true"
           	 	unique="true"
            	length="20"/>
        <property name="age"
            	column="age"
            	type="java.lang.Integer"
            	not-null="true"
            	unique="false"
            	length="0"/>
    </class>
</hibernate-mapping>

此时Hibernate将使用User类的所有字段作为版本控制信息

乐观锁相较悲观锁提高了不少性能，但是有一定的局限性，由于是在应用层加锁，如果此时在数据中直接修改数据（或其它应用程序修改数据库中的数据），应用层是无法感知到这种变化的，需要配合其它技术手段一起使用

 

转载于:https://www.cnblogs.com/sean-zou/p/3709975.html

weixin_30900589
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate的悲观锁、乐观锁
想念的专栏
08-18 292
多个用户同时访问一个数据库，则当他们的事务同时使用相 同的数据时可能会发生问题。由于并发操作带来的数据不一致性包括：丢失数据 修改、读 ” 脏 ” 数据（脏读）、不可重复读、产生幽灵数据 多个用户同时访问一个数据库，当他们的事务同时使用相同的数据时可能会发生问题。由于并发操作带来的数据不一致性包括丢失数据、修改、脏读、不可重复读、产生幽灵数据。为了解决并发问题hibernate提出了
Hibernate悲观锁和乐观锁实例详解
08-28
Hibernate悲观锁和乐观锁实例详解 Hibernate 是一个流行的基于Java的 ORM（Object-Relational Mapping）框架，提供了多种机制来确保数据的一致性和安全性。在本文中，我们将详细介绍 Hibernate 中的悲观锁和乐观锁...
自定义异常类
hit、run
09-14 169
public class BasicException extends RuntimeException{ /** 异常信息 */ protected String msg; /** 具体异常码 */ protected Integer code; /** 捕获的异常 */ protected Exception e; /** 异常Id */ protected String id; public BasicException(.
Hibernate基于配置文件（十九）并发访问与乐观锁
一名菜鸟攻城师
02-21 143
并发访问    可能引发的问题：更新丢失 （A线程把name属性改了，B线程马上改age属性，但是B线程中的name属性仍然是改之前的值，这就造成了A线程对name的更新丢失了）    ------------------------ 解决方案    *悲观锁 LockOptions.UPGRADE 虽然可以保证多线程下并发访问数据不会造成数据混乱---for update    但是，锁...
Hibernate乐观锁与悲观锁
ak364877的博客
03-12 94
悲观锁 从加载对象就开始锁定。修改过程中一直是锁。直到commit()提交后再解锁。只需要在加载对象时加上（LockOptions.UPGRADE）即可，如下所示 Info info=session.load(Info.class,"p003",LockOptions.UPGRADE); 这样带来的问题就是，当访问量大的时候就会造成排队等待的后果。 乐观锁 相对悲观...
关于hibernate悲观锁设置方法setLockMode无效而setLockOptions有效的解答
通往架构师之路
12-23 7906
最近在搞数据库的并发问题，开发环境用到了spring+hibernate的架构，数据库是mysql， 在用到悲观锁的时候发现用query.setLockMode("u", LockMode.PESSIMISTIC_WRITE);的方式无法锁定表， 打印的sql语句中也没有for update的字段。 后来换成query.setLockOptions(LockOptions.UPGRADE);
Hibernate悲观锁和乐观锁的实现
03-19
在进行Hibernate的测试时，可以创建一个名为`hibernate_test`的项目，编写对应的实体类、映射文件以及测试用例，模拟并发场景，来深入理解并对比悲观锁和乐观锁的差异和效果。 总之，理解并合理运用悲观锁和乐观锁...
Hibernate实现悲观锁和乐观锁代码介绍
08-29
Hibernate 实现悲观锁和乐观锁代码介绍 Hibernate 是一个基于 Java 的持久层框架，它提供了多种锁机制来实现事务的隔离性和一致性。在本文中，我们将详细介绍 Hibernate 实现悲观锁和乐观锁的代码实现，并讨论 ...
数据库事务、hibernate悲观锁和乐观锁
04-22
在处理并发问题时，Hibernate提供了悲观锁和乐观锁两种机制。 悲观锁假设并发环境中的冲突是常态，因此在读取数据时就立即锁定，直到事务结束才释放。在Hibernate中，可以通过设置`@LockModeType.PESSIMISTIC_READ`...
Hibernate悲观锁与乐观锁案例
07-09
在Java的持久化框架Hibernate中，悲观锁和乐观锁是两种重要的并发控制策略，它们用于管理数据库中的数据在多线程环境下的访问安全。本文将深入探讨这两种锁机制的原理、应用场景及其区别。 首先，我们来理解悲观锁...
Hibernate 乐观锁和悲观锁处理事物并发问题
m0_38068812的博客
11-11 236
一、5类事物并发问题 二、事物的隔离级别 三、处理第一类丢失更新和第二类丢失更新--使用锁机制 数据库的锁机制: 在MYSQL中 ,为了避免第二类丢失更新出现,提供了悲观锁的机制; SELECT XXX FROM XXX    FOR UPDATE; SELECT FOR UPDATE就是在数据上添加一个共享锁的东西; 1,共享锁允许其他普通的SELECT语句执行; 2,共享锁排斥...
hibernate之锁表LockMode.UPGRADE
juexinghou的专栏
04-30 2446
在Service层开启了事务，在事务中可以使用LockMode.UPGRADE，锁住该行记录（如orcal）
悲观锁和乐观锁
wtuxnz的博客
09-27 283
一、悲观锁 Hibernate本身不提供悲观锁的实现，需要依赖数据库的本身实现。 当数据库里对应的数据被悲观锁锁定时，其他人就不能读取和修改被锁定的数据，该数据的资源一直被一个人霸占着，直到该用户结束操作。 Hibernate悲观锁的使用： 调用session的get()或load()方法 调用session的lock()方法 调用Query的setLockMode()方法  通过以
ORA-01002 与 LockMode.UPGRADE
不精通则死
10-21 1751
引言：为了纪念将要离去的DBA，记下这个关于ORA-01002的日志。     ORA-01002 fetch out of sequence  Cause: In a host language program, a FETCH call was issued out of sequence.  A successful parse-and-execute call must be
hibernate(四)之乐观锁与悲观锁
faramita_of_mine的博客
01-02 873
hibernate四之乐观锁与悲观锁一、Hibernate锁机制二、ssh整合 一、Hibernate锁机制 Hibernate提供了乐观锁和悲观锁机制，主要用于解决事务并发问题。 悲观锁:Hibernate认为任何操作都可能发生并发，因此在第一个线程查询数据时，就把该条记录锁住。此时其他线程对该记录不能做任何操作（即增删改操作都不能）。必须等当前线程事务结束才可以进行操作。 悲观锁的实现原理 Hibernate悲观锁机制实际上是采用数据库的锁机制实现。 数据库中SQL语句最后加for update则把记录
MySQL锁机制
李章勇的博客
04-17 122
MySQL锁机制 　　mysql锁机制分为表级锁和行级锁，此外根据分页查询，还可以扩展出页级锁。 　　顾名思义，表级锁可以理解为锁住整个表，可以同时读，但是不能同时写,也就是说，直接锁定整张表，在你锁定期间，其它进程无法对该表进行写操作。如果你是写锁，则其它进程则读也不允许。如： select * from emp for update;  ...
Hibernate并发控制乐观锁实现——Version
关于代码的那些事
05-27 4484
乐观并发控制，可以有三种方式。 1，Version版本号 2，时间戳 3，自动版本控制。 这里不建议在新的应用程序中定义没有版本或者时间戳列的版本控制：它更慢，更复杂，如果你正在使用脱管对象，它则不会生效。 以下信息来自 : http://esffor.javaeye.com/blog/168243 通过在表中及POJO中增加一个version字段来表示记录的版
hibernate乐观锁
飞龙在天
10-13 817
乐观锁的作用 乐观锁的主要作用是为了解决事务并发带来的问题。相对于悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。 悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（Version）记录机制实现。何谓数据版本？即为数据增
Hibernate的乐观锁与悲观锁
daerduochen的专栏
05-07 74
Hibernate的乐观锁与悲观锁 锁（ locking ）业务逻辑的实现过程中，往往需要保证数据访问的排他性。如在金融系统的日终结算处理中，我们希望针对某个 cut-off 时间点的数据进行处理，而不希望在结算进行过程中（可能是几秒种，也可能是几个小时），数据再发生变化。此时，我们就需要通过一些机制来保证这些数据在某个操作过程中不会被外界修改，这样的机制，在这里，也就是所谓...
使用hibernate如何实现悲观锁和乐观锁
最新发布
04-27
Hibernate可以使用悲观锁和乐观锁来控制多个线程同时访问同一条记录时的并发性问题。 实现悲观锁的方法是，在Hibernate的查询语句中使用“for update”语句，例如： ``` Session session = sessionFactory.getCurrentSession(); Transaction tx = session.beginTransaction(); try { Item item = (Item) session.get(Item.class, itemId, LockMode.UPGRADE); item.setPrice(newPrice); session.update(item); tx.commit(); } catch (Exception e) { tx.rollback(); throw e; } ``` 在这个例子中，我们使用了LockMode.UPGRADE参数来获取悲观锁，这会在数据库中将该行记录锁定，直到事务提交或回滚为止。 要实现乐观锁，可以使用Hibernate的@Version注解来定义一个版本号属性，例如： ``` @Entity public class Item { @Id private Long id; private String name; private double price; @Version private int version; // getters and setters } ``` 在使用乐观锁的代码中，我们首先获取实体对象，修改实体对象的属性值，然后执行更新操作，例如： ``` Session session = sessionFactory.getCurrentSession(); Transaction tx = session.beginTransaction(); try { Item item = (Item) session.get(Item.class, itemId); item.setPrice(newPrice); session.update(item); tx.commit(); } catch (StaleObjectStateException e) { tx.rollback(); throw new OptimisticLockException("The item has been updated by another transaction", e); } catch (Exception e) { tx.rollback(); throw e; } ``` 在这个例子中，如果在我们修改实体对象的属性值后，有另一个事务已经修改了该实体对象，那么我们就会捕获到StaleObjectStateException异常，这时我们就可以回滚事务并抛出一个OptimisticLockException异常，提示用户该实体对象已经被其他事务修改过了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值