hibernate 对悲观锁及乐观锁的支持

最新推荐文章于 2023-08-09 08:35:10 发布
最新推荐文章于 2023-08-09 08:35:10 发布
阅读量118 收藏
点赞数
分类专栏： Hibernate 文章标签： Hibernate SQL MySQL junit VSS
在实际应用中常常会出现这种情况，两个人同时读取同一条数据，然后其中一个人对这条数据进行了修改，之后另外一个人也对这条数据进行修改，后来修改数据的人会覆盖先修改那个人的数据，这种情况叫做数据更新丢失。

hibernate提供两种方式来解决这种问题：悲观锁和乐观锁的方式。

悲观锁：

悲观锁的实现，通常依赖于数据库机制，在整个过程中将数据锁定，其它任何用户都不能读取或修改，即以独占的方式。例如微软的VSS。

乐观锁：

乐观锁大多数基于数据版本记录机制（version）实现，一般是在数据库表中加入一个version字段，读取数据时将版本号一同读出，之后更新数据时版本号加一，如果提交数据时版本号小于或等于数据表中的版本号，则认为数据是过期的，否则给予更新。即以版本的方式。例如CVS.

hibernate悲观锁例子：

1.实体类： 

package com.yx.zzg.pojo;

public class Inventory {

	private int id;

	private String itemName;

	private int quantity;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getItemName() {
		return itemName;
	}

	public void setItemName(String itemName) {
		this.itemName = itemName;
	}

	public int getQuantity() {
		return quantity;
	}

	public void setQuantity(int quantity) {
		this.quantity = quantity;
	}

}


2.映射文件 

<?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 package="com.yx.zzg.pojo">
	<class name="Inventory" table="t_inventory">
		<id name="id">
			<!-- 指定主键生成策略 -->
			<generator class="native" />
		</id>
		<property name="itemName" />
		<property name="quantity" />
	</class>

</hibernate-mapping>


3.hibernate配置文件 

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost/hibernate_pessimistic_lock</property>
		<property name="connection.username">root</property>
		<property name="connection.password">123456</property>
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<!-- 是否显示执行的sql语句 -->
		<property name="show_sql">true</property>
		<!-- 显示执行的sql语句是否格式化 -->
		<property name="format_sql">true</property>
		<!-- 是否自动创建表，参数详见HIBERNATE_HOME/etc/hibernate.properties文件 -->
		<!--
			<property name="hibernate.hbm2ddl.auto">create</property>
		-->
		<mapping resource="com/yx/zzg/pojo/Inventory.hbm.xml" />
	</session-factory>
</hibernate-configuration>


4.测试类： 

package com.yx.zzg.test;

import java.util.Date;
import java.util.Iterator;
import java.util.Set;

import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yx.zzg.pojo.Inventory;
import com.yx.zzg.util.HibernateUtil;

import junit.framework.TestCase;

/**
 * 测试方法：在testLoad1方法中打一个断点，运行到更新前停止，开始运行testLoad2方法，会发现testLoad2方法中的不会打印数据，
 * 当testLoad1一方法运行完之后testLoad2方法才会继续运行
 * 
 * @author toshiba
 * 
 */
public class TestUser extends TestCase {

	public void testLoad1() {
		Session session = null;
		Transaction tx = null;
		try {
			session = HibernateUtil.getSession();
			tx = session.beginTransaction();
			// 发出sql语句，lazy失效
			//LockMode.UPGRADE指示独占的方式（悲观锁）
			Inventory inventory = (Inventory) session.load(Inventory.class, 1,
					LockMode.UPGRADE);
			// 不发sql
			System.out.println("ItemName=" + inventory.getItemName());
			System.out.println("Quantity=" + inventory.getQuantity());

			inventory.setQuantity(inventory.getQuantity() - 200);

			tx.commit();
		} catch (HibernateException e) {
			throw e;
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

	public void testLoad2() {
		Session session = null;
		Transaction tx = null;
		try {
			session = HibernateUtil.getSession();
			tx = session.beginTransaction();

			Inventory inventory = (Inventory) session.load(Inventory.class, 1,
					LockMode.UPGRADE);

			System.out.println("ItemName=" + inventory.getItemName());
			System.out.println("Quantity=" + inventory.getQuantity());

			inventory.setQuantity(inventory.getQuantity() - 200);

			tx.commit();
		} catch (HibernateException e) {
			throw e;
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

}



hibernate乐观锁例子：

1.实体类： 

package com.yx.zzg.pojo;

public class Inventory {

	private int id;

	private String itemName;

	private int quantity;

	private int version;

	public int getVersion() {
		return version;
	}

	public void setVersion(int version) {
		this.version = version;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getItemName() {
		return itemName;
	}

	public void setItemName(String itemName) {
		this.itemName = itemName;
	}

	public int getQuantity() {
		return quantity;
	}

	public void setQuantity(int quantity) {
		this.quantity = quantity;
	}

}


2.映射文件 

<?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 package="com.yx.zzg.pojo">
	<!-- optimistic-lock="version"指示该实体的加载是需要乐观锁的 ，这个乐观锁的支持是根据版本号-->
	<class name="Inventory" table="t_inventory" optimistic-lock="version">
		<id name="id">
			<!-- 指定主键生成策略 -->
			<generator class="native" />
		</id>

		<!-- 指示版本字段，该字段会有hibernate来维护 -->
		<!-- version标签必须放在id标签下面 -->
		<version name="version" />
		<property name="itemName" />
		<property name="quantity" />
	</class>

</hibernate-mapping>


3.测试类： 

package com.yx.zzg.test;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.yx.zzg.pojo.Inventory;
import com.yx.zzg.util.HibernateUtil;

import junit.framework.TestCase;

/**
 * 测试方法：在testLoad1方法中打一个断点，运行到更新前停止，开始运行testLoad2方法，这时testLoad2方法能正确执行，
 * 能够打印出结果也能正常更新数据库中的数据
 * ，并且将数据库中的version字段更新+1.此时接着运行testLoad1方法，则会抛出异常，因为这时testLoad1方法更新的是已过时的数据。
 * 
 * @author toshiba
 * 
 */
public class TestUser extends TestCase {

	public void testLoad1() {
		Session session = null;
		Transaction tx = null;
		try {
			session = HibernateUtil.getSession();
			tx = session.beginTransaction();
			// 不会发出sql。
			Inventory inventory = (Inventory) session.load(Inventory.class, 1);
			// 发出sql，正常打印
			System.out.println("ItemName=" + inventory.getItemName());
			System.out.println("Quantity=" + inventory.getQuantity());

			inventory.setQuantity(inventory.getQuantity() - 200);

			tx.commit();
		} catch (HibernateException e) {
			throw e;
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

	public void testLoad2() {
		Session session = null;
		Transaction tx = null;
		try {
			session = HibernateUtil.getSession();
			tx = session.beginTransaction();

			Inventory inventory = (Inventory) session.load(Inventory.class, 1);
			// 能够正常打印
			System.out.println("ItemName=" + inventory.getItemName());
			System.out.println("Quantity=" + inventory.getQuantity());
			inventory.setQuantity(inventory.getQuantity() - 200);
			// 发出一条根据ID和版本号来更新数据的sql语句
			tx.commit();
		} catch (HibernateException e) {
			throw e;
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

}
skyuck
关注
专栏目录
Hibernate悲观锁/乐观锁
yh_zeng2的博客
07-03 425
默认事务之间会产生数据冲突，所以要求事务在读取数据的时候就对数据加锁，保证数据访问的排它性； 该锁将一直被事务持有，直到事务结束才会释放锁。 一、悲观锁 最常用的，是对查询进行加锁（LockMode.UPGRADE和LockMode.UPGRADE_NOWAIT），悲观锁的可以通过以下三种方式实现： 1）调用Session.load()，并设置了LockMode 2）调用Session.
Hibernate实现悲观锁和乐观锁代码介绍
08-29
Hibernate 实现悲观锁和乐观锁代码介绍 Hibernate 是一个基于 Java 的持久层框架，它提供了多种锁机制来实现事务的隔离性和一致性。在本文中，我们将详细介绍 Hibernate 实现悲观锁和乐观锁的代码实现，并讨论 ...
hibernate悲观锁和乐观锁
iteye_10403的博客
08-29 109
1.悲观锁 它指的是对数据被外界修改持保守态度。假定任何时刻存取数据时，都可能有另一个客户也正在存取同一笔数据，为了保持数据被操作的一致性，于是对数据采取了数据库层次的锁定状态，依靠数据库提供的锁机制来实现。 基于jdbc实现的数据库加锁如下： select * from account where name="test" for update 在更新的过程中，数据库处于加锁状态，任何其他...
hibernate 悲观锁
greatmind829的专栏
06-21 464
相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（Version）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个
Hibernate悲观锁
最新发布
unber的博客
08-09 212
悲观锁（pessimistic lock）是指在每次操作数据时，总是悲观地认为会有其他事务操作同一数据，因此，在整个数据处理过程中，会把数据处于锁定状态。悲观锁具有排他性，一般由数据库实现。在锁定时间内，其他事务不能对数据进行存取等操作，这可能导致长时间的等待问题。在中，用户可以显示地设定锁模式，通常在应用中会设定如下两种锁模式。
Hibernate悲观锁和乐观锁的实现
03-19
在进行Hibernate的测试时，可以创建一个名为`hibernate_test`的项目，编写对应的实体类、映射文件以及测试用例，模拟并发场景，来深入理解并对比悲观锁和乐观锁的差异和效果。 总之，理解并合理运用悲观锁和乐观锁...
数据库事务、hibernate悲观锁和乐观锁
04-22
在处理并发问题时，Hibernate提供了悲观锁和乐观锁两种机制。 悲观锁假设并发环境中的冲突是常态，因此在读取数据时就立即锁定，直到事务结束才释放。在Hibernate中，可以通过设置`@LockModeType.PESSIMISTIC_READ`...
Hibernate的乐观锁与悲观锁
05-24
### Hibernate的乐观锁与悲观锁 #### 一、引言 在并发环境下，尤其是在金融、电商等业务场景中，确保数据的一致性和完整性至关重要。**Hibernate**作为一种流行的Java持久层框架，提供了多种机制来处理并发控制...
Hibernate锁机制_悲观锁和乐观锁
03-14
Hibernate锁机制_悲观锁和乐观锁
快速掌握Hibernate中悲观锁和乐观锁(转)
Dream In Coding
05-25 204
我们在使用Hibernate中经常用到当多个人对同一数据同时进行修改的时候，会发生脏数据，造成数据的不一致性，解决办法是可以通过悲观锁和乐观锁来实现。 Hibernate悲观锁：在数据有加载的时候就给其进行加锁，直到该锁被释放掉，其他用户才可以进行修改，优点：数据的一致性保持得很好，缺点：不适合多个用户并发访问。当一个锁住的资源不被释放掉的时候，这个资源永远不会被其他用户进行修改，容易造成无限期...
Hibernate的 悲观锁 乐观锁
qq_42383787的博客
03-13 181
悲观锁 在应用程序中显示地为数据资源加锁.悲观锁假定当前事务操纵数据资源时,肯定还会有其它事务同时访问该数据资源,为了避免当前事务的操作受到干扰,先锁定资源.尽管悲观锁能防止丢失更新和不可重复读这类并发问题,但会影响并发性能. 乐观锁 假定当前事务操纵数据资源时,不会有其它事务同时访问该数据资源,因此完全依靠数据库的隔离级别来自动管理锁的工作.应用程序采用版本控制手段来避免可能出现的并发问题. ...
Hibernate的悲观锁和乐观锁机
qq_44691484的博客
07-31 123
有些业务逻辑在执行过程中要求对数据进行排他性的访问，于是需要通过一些机制保证在此过程中数据被锁住不会被外界修改，这就是所谓的锁机制。 Hibernate支持悲观锁和乐观锁两种锁机制。悲观锁，顾名思义悲观的认为在数据处理过程中极有可能存在修改数据的并发事务（包括本系统的其他事务或来自外部系统的事务），于是将处理的数据设置为锁定状态。悲观锁必须依赖数据库本身的锁机制才能真正保证数据访问的排他性，乐观锁，顾名思义，对并发事务持乐观态度（认为对数据的并发操作不会经常性的发生），通过更加宽松的锁机制来解决由于悲观锁排
Hibernate悲观锁-乐观锁
java进阶之路的博客
09-09 208
Hibernate 乐观锁-悲观锁原理及使用
Hibernate的悲观锁和乐观锁
本是后山人
09-18 293
原文：https://www.w3cschool.cn/hibernate_articles/6qzu1ioy.html 悲观锁 悲观锁（ Pessimistic Locking ），正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的...
hibernate中悲观锁 乐观锁
oracle_my_love的专栏
07-13 264
hibernate中经常用到当多个人对同一数据同时进行修改的时候，会发生脏数据，造成数据的不一致性，解决办法是可以通过悲观锁和乐观锁来实现。  悲观锁：在数据有加载的时候就给其进行加锁，直到该锁被释放掉，其他用户才可以进行修改， 优点：数据的一致性保持得很好，缺点：不适合多个用户并发访问，依赖于数据库锁机制， 当一个锁住的资源不被释放掉的时候，这个资源永远不会被其他用户进行修改，容易造成无限...
悲观锁
红桃峰峰 的博客
08-02 901
为了避免读写数据不及时,导致脏数据产生的问题，hibernate引入了悲观锁和乐观锁。 下面先介绍悲观锁 悲观锁 新建一个java项目，结构如图： 实体类User代码： package com.robert.pojo; public class User { private int id ; private String nam
Hibernate中的悲观锁和乐观锁
Edward_hjh的博客
09-08 200
@[TOC]Hibernate中的悲观锁和乐观锁 Hibernate中的悲观锁和乐观锁 用途：主要用来解决并发问题。锁是一种排他性的操作 悲观锁：对数据库的记录加锁，不支持懒加载. 实现策略：通常依赖于数据库机制，在整个过程中将数据锁定，其它任何用户都不能读取或修改，适合于短事物的操作. 加锁代码： Inventory inv = (Inventory)session.load (Inventory.class, 1, LockMode.UPGRADE); //查询记录的时候顺便加了一个悲观锁 //由于悲观
Hibernate悲观锁与乐观锁详解
"本文主要探讨了Hibernate框架中的两种锁机制——悲观锁和乐观锁，以及它们的原理和应用场景。" 悲观锁与乐观锁是数据库事务处理中的重要概念，主要用于处理多用户并发操作时的数据一致性问题。在Hibernate中，这两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值