Hibernate 事务的并发处理

最新推荐文章于 2022-06-04 22:37:05 发布
原创 最新推荐文章于 2022-06-04 22:37:05 发布 · 144 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Hibernate #Cache #JDBC #Oracle #SQL

本文详细介绍了数据库事务的概念及其ACID特性，并探讨了事务中可能遇到的问题如丢失更新、脏读等。此外，还深入讲解了解决这些问题的事务隔离级别，并通过示例展示了悲观锁与乐观锁的具体应用。

事务定义：数据库事务是指由一个或多个SQL语句组成的工作单元，这个工作单元中的SQL语句相互依赖，如果有一个SQL语句执行失败，就必须撤销整个工作单元。

事务的特性ACID：原子性，一致性，独立性，持久性

 

事务可能出现的问题：

  1. 第一类丢失更新 lost update

  2. 脏读， 读到还没体检的事务数据 dirty read

  3. non-repeatable read 不可重复读

  4. second lost update problem 第二次丢失更新

  5. phantom read 幻读（插入和删除）

只要考虑2，3，5 其他都是特殊情况

 

处理这些问题的解决方案，就是事务的隔离机制：

1，read-uncommitted   2，read-committed  4，repeatable read  8，serializable

只要是数据库支持事务，就不会出现上面的第一种情况（lost update）

read-uncommitted会出现2，3，5的问题

read-committed  会出现 3，5 的问题

 serializable可解决所有问题，但是效率很低

 

所以我们在程序中一般设定Hibernate的隔离级别为2（read-committed ）

乐观锁和悲观锁的前提也就是hibernate.conection.isolation=2 也就是隔离级别为read-committed

悲观锁是依赖数据库中的锁，  而乐观锁是在程序中做处理，  所以乐观锁的效率要高

 

下面就先看一个使用悲观锁的简单例子：

package com.lbx.hibernate;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Account {
	private int id;
	private int balance; //BigDecimal
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getBalance() {
		return balance;
	}
	public void setBalance(int balance) {
		this.balance = balance;
	}
	
	
}

 

<?xml version='1.0' encoding='utf-8'?>
<!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/testhib</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
       <!--
        <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:SXT</property>
        <property name="connection.username">scott</property>
        <property name="connection.password">tiger</property>
      	<property name="dialect">org.hibernate.dialect.OracleDialect</property>
       -->

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache 
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
		 -->
		 
		<property name="cache.use_second_level_cache">true</property>
		<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
		<property name="cache.use_query_cache">true</property>
		 
        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>

        <!-- Drop and re-create the database schema on startup
        <property name="hbm2ddl.auto">update</property>
		 -->
        <mapping class="com.lbx.hibernate.Account"/>
        
    </session-factory>

</hibernate-configuration>

 

package com.lbx.hibernate;

import org.hibernate.LockMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import com.lbx.hibernate.Account;

public class HibernateCacheTest {
	private static SessionFactory sf;
	
	@BeforeClass
	public static void beforeClass() {
		sf = new AnnotationConfiguration().configure().buildSessionFactory();
	}
	@AfterClass
	public static void afterClass() {
		sf.close();
	}
	
	@Test
	public void testSchemaExport() {
		new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);
	}
	
	@Test
	public void testSave() {
		Session session = sf.openSession();
		session.beginTransaction();
		
		Account a = new Account();
		a.setBalance(100);
		session.save(a);
			
		session.getTransaction().commit();
		session.close();
	}
	
	//没加悲观锁之前，可能会出问题
	@Test
	public void testOperation1() {
		Session session = sf.openSession();
		session.beginTransaction();
		
		Account a = (Account)session.load(Account.class, 1);
		int balance = a.getBalance();
		//没完成之前做点其他的事
		balance = balance - 10;
		a.setBalance(balance);
		session.getTransaction().commit();
		session.close();
	}
	
	//加了悲观锁之后，就可以解决问题
	@Test
	public void testPessimisticLock() {
		Session session = sf.openSession();
		session.beginTransaction();
		
		Account a = (Account)session.load(Account.class, 1, LockMode.UPGRADE);
		int balance = a.getBalance();
		//do some caculation
		balance = balance - 10;
		a.setBalance(balance);
		session.getTransaction().commit();
		session.close();
	}
	
	public static void main(String[] args) {
		beforeClass();
	}
}

 

 

下面就是一个乐观锁的简单例子（加了个标记version）： 

package com.lbx.hibernate;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Version;

@Entity
public class Account {
	private int id;
	private int balance;
	private int version;    
	@Version
	public int getVersion() {
		return version;
	}
	public void setVersion(int version) {
		this.version = version;
	}
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getBalance() {
		return balance;
	}
	public void setBalance(int balance) {
		this.balance = balance;
	}
	
	
}

 

<?xml version='1.0' encoding='utf-8'?>
<!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/testhib</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
       <!--
        <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:SXT</property>
        <property name="connection.username">scott</property>
        <property name="connection.password">tiger</property>
      	<property name="dialect">org.hibernate.dialect.OracleDialect</property>
       -->

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache 
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
		 -->
		 
		<property name="cache.use_second_level_cache">true</property>
		<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
		<property name="cache.use_query_cache">true</property>
		 
        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>

        <!-- Drop and re-create the database schema on startup
        <property name="hbm2ddl.auto">update</property>
		 -->
        <mapping class="com.lbx.hibernate.Account"/>
        
    </session-factory>

</hibernate-configuration>

 

package com.lbx.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import com.lbx.hibernate.Account;

public class HibernateCacheTest {
	private static SessionFactory sf;

	@BeforeClass
	public static void beforeClass() {
		sf = new AnnotationConfiguration().configure().buildSessionFactory();
	}

	@AfterClass
	public static void afterClass() {
		sf.close();
	}

	@Test
	public void testSchemaExport() {
		new SchemaExport(new AnnotationConfiguration().configure()).create(
				false, true);
	}

	@Test
	public void testSave() {
		Session session = sf.openSession();
		session.beginTransaction();

		Account a = new Account();
		a.setBalance(100);
		session.save(a);

		session.getTransaction().commit();
		session.close();
	}

	//测试乐观锁
	@Test
	public void testOptimisticLock() {
		Session session = sf.openSession();

		Session session2 = sf.openSession();

		session.beginTransaction();
		Account a1 = (Account) session.load(Account.class, 1);

		session2.beginTransaction();
		Account a2 = (Account) session2.load(Account.class, 1);
		
		a1.setBalance(900);
		a2.setBalance(1100);

		session.getTransaction().commit();   //提交之后，改变了
		System.out.println(a1.getVersion());

		session2.getTransaction().commit();   //所以在这提交再改变数据就报错
		System.out.println(a2.getVersion());

		session.close();
		session2.close();
	}

	public static void main(String[] args) {
		beforeClass();
	}
}

  

 

【数据库】数据库入门（十二）: 数据库事务（Database Transactions）
Ulrich蚊子Blog
11-03 1642
定义 DBMS 提供了事务（Transactions）支持。事务是作为 DBMS 中的逻辑单元分组执行的一系列数据库操作。与在DBMS之外执行程序（例如，C程序）在许多方面都不同！ 数据库应用程序通常通过事务而不是单个操作访问数据库。例如，大型数据库和数百个并发用户：银行、超市收银台、机票预订、在线购买等。 之所以使用事务是因为它们可以在以下情况下实施数据完整性：多个用户可以同时修改和共享...
Lost Update | Dirty Read | Unrepeatable Read | Phantom Read
wwq518的博客
04-27 2085
Lost Update | Dirty Read | Unrepeatable Read | Phantom Read
【数据库】事务并发
m0_51689298的博客
05-20 361
我在这里只说三种可能出现的问题：Lost updates problemUncommitted updates problemIncorrect analysis problem Lost updates problem 一个事件的write操作，会覆盖掉另一个事件已经执行的write操作。 Successfully completed update is overridden by another user. Uncommitted updates problem 这个可以看作是我们在别的地方看到的“脏
mysql丢失更新问题
远方的少年
10-29 1819
mysql丢失更新问题英文叫lost update.指的是两个事务同时更新一条数据，后更新的覆盖了前面更新的结果，从结果上看第一次的更新丢失了的现象。脏读，幻读，不可重复读是读的问题，丢失更新是写的问题。其实现在数据库本身并没有丢失更新的问题，因为当一个事务更新一条记录时，就会加排他锁，另外一个的更新就会阻塞住。通常都是由于程序产生的。可以通过乐观锁的方式来解决这个问题。 ...
【数据库基础】事务控制（Transaction）Part 1
YFY20020109的博客
06-04 1137
本文总结了：事务、事务并发问题、并发控制、调度、上锁、2PL、可串行性
hibernate错误:脏读
人生百年几今日，今日不为真可惜。
07-02 2416
在隔离级别的影响下，它不会出现错误，但是读取不出来数据，后面的程序会读取不出来，尽量减小这种错误，不要脏的，重复读。
掌握Hibernate事务并发处理技巧
### Hibernate教程26_事务并发处理知识点 #### 标题解析 Hibernate教程系列是针对使用Hibernate框架的开发者而提供的学习材料，旨在帮助开发者深入理解并掌握Hibernate框架的使用。标题“Hibernate教程26_事务并发...
Hibernate事务并发处理与隔离级别解析
"hibernate 对事务并发处理" 在IT领域，尤其是Java开发中，Hibernate作为一款流行的ORM（对象关系映射）框架，处理事务并发控制是确保数据一致性和正确性的关键。事务的并发处理涉及到数据库的ACID特性，即原子性...
hibernate 对事务并发处理
06-24
Hibernate 对事务并发处理 在 Hibernate 中，对事务并发处理是非常重要的， especialmente 在多用户环境中。事务处理的目的是为了保证数据的可靠性和一致性。 事务四个特性 ACID 1. 原子性（Atomicity）：事务...
Hibernate事务与并发问题处理.pdf
12-31
【标题】：Hibernate事务与并发问题处理 【描述】：本文深入探讨了在使用Hibernate框架时，如何管理和解决事务及并发问题。主要关注点在于事务的ACID特性以及并发操作可能导致的数据不一致性。 【标签】：技术 ...
Hibernate事务与并发问题处理[收集].pdf
10-11
Hibernate事务与并发问题处理[收集].pdf
不更改数据库默认隔离级别，如何避免丢失更新（lost update）
java开发指南博客 【转载】
07-23 669
在默认的隔离级别下先读出数据然后再去修改可能会产生Lost update,但是如果提高隔离级别的话又会降低并发，使用下面的办法可以在Read commited隔离级别上避免Lost update. 1.可以使用衍生列比如timestamp.在更新之前先做检查，如果更新的时候发现 timestamp列已经更改说明列已经被修改了，报错。 2.使用存储过程，如果更新返回的值为0，说明之前数据已经被更...
Hibernate框架，事务（脏读幻读不可重复读）
qq_35240226的博客
10-05 995
1、什么是Hibernate，好处是什么？ 答：  1）Hibernate是一个操作数据库的框架，实现了对JDBC的封装；   2）Hibernate是一个ORM（对象关系映射）框架，我们在写程序时 ，用的时面向对象的方法，但是在关系型数据库里，存的是一条条的数据，为了用纯面向对象的思想解决问题，所有需要将程序中的对象和数据库的记录建立起映射关系，ORM就是这样的技术，而Hibernat...
This famous problem is known as a "lost update"
xray 的自由梦想
07-07 1329
Each of the instances of the component performs the following steps:1. Read an integer X from a database.2. Add 10 to X.3. Write the new value of X to the database. If each these three steps exceutes
丢失更新的问题产生和解决
BigData
10-09 1209
主要概念: 图示解析: 丢失更新的问题产生和解决:
Spring事务传播机制和数据库隔离级别
zhxing
04-15 239
 先看下Spring的事务传播行为类型   事务传播行为类型 说明 PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGA...
用于生成路线的 语音文件
最新发布
12-27
用于生成路线的 语音文件
jdk1.8.0-201.rar
12-27
先展示下效果 https://pan.quark.cn/s/a4b39357ea24 Dart2JS is the Dart-to-JavaScript compiler for Dart. This compiler will provide high-quality translation from Dart to JavaScript. Some areas that will explored in this project are: * high-performance extensible scanner and parser * concrete type inferencing * fancy language tool support * programming environment integration * SSA-based intermediate representation * adaptive compilation on the client
deep-person-reid-master.zip
12-27
行人重识别（Person Re-identification也称行人再识别，简称为ReID，是利用计算机视觉技术判断图像或者视频序列中是否存在特定行人的技术；或者说，行人重识别是指在已有的可能来源与非重叠摄像机视域的视频序列中识别出目标行人。广泛被认为是一个图像检索的子问题。给定一个监控行人图像，检索跨设备下的该行人图像。在监控视频中，由于相机分辨率和拍摄角度的缘故，通常无法得到质量非常高的人脸图片。当人脸识别失效的情况下，ReID就成为了一个非常重要的替代品技术。ReID有一个非常重要的特性就是跨摄像头，所以学术论文里评价性能的时候，是要检索出不同摄像头下的相同行人图片。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值