HQL的悲观锁和乐观锁

最新推荐文章于 2022-10-15 21:06:22 发布
最新推荐文章于 2022-10-15 21:06:22 发布
阅读量318 收藏
点赞数
分类专栏： javaee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36869329/article/details/80715196
版权

悲观锁 就是读写时都加锁

package hibernate_manytomany;

import java.util.Date;

import org.hibernate.LockMode;
import org.hibernate.Session;

import hibernate.belle.Inventory;
import hibernate.belle.FiscalPK;
import hibernate.belle.HibernateUtils;

import junit.framework.TestCase;

public class Extends extends TestCase{


     public void teststore(){


           Session session=null;
           try{ 
                session=HibernateUtils.getSession();
                session.beginTransaction();

                Inventory inv=new Inventory();
                inv.setItemno(1001);
                inv.setName("zara");
                inv.setQuantity(100);

                session.save(inv);
               session.beginTransaction().commit();
           }catch(Exception e)
           {
               e.printStackTrace();
               session.beginTransaction().rollback();

           }finally{

               HibernateUtils.closeSession(session);
           }
         }

     public void testrevise1(){


           Session session=null;
           try{ 
                session=HibernateUtils.getSession();
                session.beginTransaction();

                Inventory inv=(Inventory)session.load(Inventory.class, 1001,LockMode.UPGRADE);

                inv.setQuantity(inv.getQuantity()-20);
                System.out.println("quantity="+inv.getQuantity());

               session.beginTransaction().commit();
           }catch(Exception e)
           {
               e.printStackTrace();
               session.beginTransaction().rollback();

           }finally{

               HibernateUtils.closeSession(session);
           }
         }
     public void testrevise2(){


           Session session=null;
           try{ 
                session=HibernateUtils.getSession();
                session.beginTransaction();

                Inventory inv=(Inventory)session.load(Inventory.class, 1001，LockMode.UPDATE);

                inv.setQuantity(inv.getQuantity()-20);
                System.out.println("2=="+inv.getQuantity());

               session.beginTransaction().commit();
           }catch(Exception e)
           {
               e.printStackTrace();
               session.beginTransaction().rollback();

           }finally{

               HibernateUtils.closeSession(session);
           }
         }
}

当我对1单步调试 不释放的时候 直接run2 会报错

Hibernate: 
    select
        inventory0_.Itemno as Itemno0_0_,
        inventory0_.name as name0_0_,
        inventory0_.quantity as quantity0_0_ 
    from
        t_inv inventory0_ 
    where
        inventory0_.Itemno=? for update

20:37:27,356  WARN JDBCExceptionReporter:77 - SQL Error: 1205, SQLState: 41000
20:37:27,359 ERROR JDBCExceptionReporter:78 - Lock wait timeout exceeded; try restarting transaction
org.hibernate.exception.GenericJDBCException: could not load an entity: [hibernate.belle.Inventory#1001]
    at org.hibernate.exception.SQLStateConverter.handledNonSpecificException(SQLStateConverter.java:103)
    at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:91)
    at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:43)
    at org.hibernate.loader.Loader.loadEntity(Loader.java:1865)
    at org.hibernate.loader.entity.AbstractEntityLoader.load(AbstractEntityLoader.java:48)
    at org.hibernate.loader.entity.AbstractEntityLoader.load(AbstractEntityLoader.java:42)
    at org.hibernate.persister.entity.AbstractEntityPersister.load(AbstractEntityPersister.java:3038)
    at org.hibernate.event.def.DefaultLoadEventListener.loadFromDatasource(DefaultLoadEventListener.java:395)
    at org.hibernate.event.def.DefaultLoadEventListener.doLoad(DefaultLoadEventListener.java:375)
    at org.hibernate.event.def.DefaultLoadEventListener.load(DefaultLoadEventListener.java:139)
    at org.hibernate.event.def.DefaultLoadEventListener.lockAndLoad(DefaultLoadEventListener.java:297)
    at org.hibernate.event.def.DefaultLoadEventListener.onLoad(DefaultLoadEventListener.java:106)
    at org.hibernate.impl.SessionImpl.fireLoad(SessionImpl.java:878)
    at org.hibernate.impl.SessionImpl.load(SessionImpl.java:859)
    at org.hibernate.impl.SessionImpl.load(SessionImpl.java:854)
    at hibernate_manytomany.Extends.testrevise1(Extends.java:51)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:497)
    at junit.framework.TestCase.runTest(TestCase.java:154)
    at junit.framework.TestCase.runBare(TestCase.java:127)
    at junit.framework.TestResult$1.protect(TestResult.java:106)
    at junit.framework.TestResult.runProtected(TestResult.java:124)
    at junit.framework.TestResult.run(TestResult.java:109)
    at junit.framework.TestCase.run(TestCase.java:118)
    at org.eclipse.jdt.internal.junit.runner.junit3.JUnit3TestReference.run(JUnit3TestReference.java:131)
    at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
    at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)
Caused by: java.sql.SQLException: Lock wait timeout exceeded; try restarting transaction
    at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1073)
    at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3603)
    at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3535)
    at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:1989)
    at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2150)
    at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2626)
    at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:2119)
    at com.mysql.jdbc.PreparedStatement.executeQuery(PreparedStatement.java:2281)
    at org.hibernate.jdbc.AbstractBatcher.getResultSet(AbstractBatcher.java:186)
    at org.hibernate.loader.Loader.getResultSet(Loader.java:1778)
    at org.hibernate.loader.Loader.doQuery(Loader.java:662)
    at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:224)
    at org.hibernate.loader.Loader.loadEntity(Loader.java:1851)
    ... 28 more

乐观锁

package hibernate.belle;

import java.util.Date;

public class Inventory {
      private int itemno;
      private int quantity;
      private String name;
      private int version;


    public int getItemno() {
        return itemno;
    }
    public void setItemno(int itemno) {
        this.itemno = itemno;
    }
    public int getQuantity() {
        return quantity;
    }
    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getVersion() {
        return version;
    }
    public void setVersion(int version) {
        this.version = version;
    }



}

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

<hibernate-mapping >
 <class name="hibernate.belle.Inventory" table="t_inv" optimistic-lock="version">

     <id name="Itemno">

     <generator class="assigned"></generator>

     </id>
     <version name="version"/>
     <property name="name"></property>
     <property name="quantity"></property>


 </class>      
</hibernate-mapping>
package hibernate_manytomany;

import java.util.Date;

import org.hibernate.LockMode;
import org.hibernate.Session;

import hibernate.belle.Inventory;
import hibernate.belle.FiscalPK;
import hibernate.belle.HibernateUtils;

import junit.framework.TestCase;

public class Extends extends TestCase{


     public void teststore(){


           Session session=null;
           try{ 
                session=HibernateUtils.getSession();
                session.beginTransaction();

                Inventory inv=new Inventory();
                inv.setItemno(1001);
                inv.setName("zara");
                inv.setQuantity(100);

                session.save(inv);
               session.beginTransaction().commit();
           }catch(Exception e)
           {
               e.printStackTrace();
               session.beginTransaction().rollback();

           }finally{

               HibernateUtils.closeSession(session);
           }
         }

     public void testrevise1(){


           Session session=null;
           try{ 
                session=HibernateUtils.getSession();
                session.beginTransaction();

                Inventory inv=(Inventory)session.load(Inventory.class, 1001);

                inv.setQuantity(inv.getQuantity()-20);
                System.out.println("revise1"+inv.getVersion());
                System.out.println("quantity="+inv.getQuantity());

               session.beginTransaction().commit();
           }catch(Exception e)
           {
               e.printStackTrace();
               session.beginTransaction().rollback();

           }finally{

               HibernateUtils.closeSession(session);
           }
         }
     public void testrevise2(){


           Session session=null;
           try{ 
                session=HibernateUtils.getSession();
                session.beginTransaction();

                Inventory inv=(Inventory)session.load(Inventory.class, 1001);

                inv.setQuantity(inv.getQuantity()-20);
                System.out.println("revise2"+inv.getVersion());
                System.out.println("quantity="+inv.getQuantity());

               session.beginTransaction().commit();
           }catch(Exception e)
           {
               e.printStackTrace();
               session.beginTransaction().rollback();

           }finally{

               HibernateUtils.closeSession(session);
           }
         }
}

同上 1先占着锁 不释放 然后2直接run 报错 因为 此时数据库里查到的version是1 与1现在所持有的version0 不匹配 报一下错

20:56:22,810 ERROR AbstractFlushingEventListener:301 - Could not synchronize database state with session
org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)
Belle唯唯
关注
专栏目录
Hibernate悲观锁/乐观锁
yh_zeng2的博客
07-03 421
默认事务之间会产生数据冲突，所以要求事务在读取数据的时候就对数据加锁，保证数据访问的排它性； 该锁将一直被事务持有，直到事务结束才会释放锁。 一、悲观锁 最常用的，是对查询进行加锁（LockMode.UPGRADE和LockMode.UPGRADE_NOWAIT），悲观锁的可以通过以下三种方式实现： 1）调用Session.load()，并设置了LockMode 2）调用Session.
MySQL中的悲观锁和乐观锁
彳亍
01-27 1162
悲观锁（即悲观并发控制）和乐观锁（即乐观并发控制）是数据库系统中并发控制主要采用的技术手段。针对不同的业务场景，应该选用不同的并发控制方式。
hibernate 乐观锁与悲观锁使用
iamweiming的专栏
05-23 203
Hibernate支持两种锁机制：  即通常所说的“悲观锁（Pessimistic Locking）”和 “乐观锁（OptimisticLocking）”。  悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。  Hibernate的加锁模式有：  Ø Lo...
hibernate 乐观锁与悲观锁使用方法
江南才子
06-24 772
Hibernate支持两种锁机制：  即通常所说的“悲观锁（Pessimistic Locking）”和 “乐观锁（OptimisticLocking）”。 悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。 Hibernate的加锁模式有：  Ø LockMode
Hibernate的悲观锁和乐观锁
复制乔布斯
04-28 394
一，为接下来的测试添加java实体类和建立数据库映射表account:    1, 项目目录：        2、用户实体类：Account： package com.hibtest.entity; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; impor
Hibernate锁机制_悲观锁和乐观锁
03-14
Hibernate锁机制_悲观锁和乐观锁
MySQL中乐观锁和悲观锁
timchen525的专栏
06-20 552
乐观锁：乐观的认为操作不会导致冲突，在操作数据时，并不进行任何其他特殊处理（也就是不加锁），而是在进行更新时，再去判断是否有冲突。MySQL数据库不支持乐观锁，需要开发者自己实现。乐观者开发者通常实现方案：给表添加一个版本号或者时间戳（基于version、基于timestamp字段），每次操作后，将记录的版本号加1。实际的做法为，先查询出来那条记录，获取version字段，如果要对那条记录进行更新...
Hibernate悲观锁与乐观锁案例
07-09
在Java的持久化框架Hibernate中，悲观锁和乐观锁是两种重要的并发控制策略，它们用于管理数据库中的数据在多线程环境下的访问安全。本文将深入探讨这两种锁机制的原理、应用场景及其区别。 首先，我们来理解悲观锁...
Java的Hibernate框架数据库操作中锁的使用和查询类型
09-02
在Java的Hibernate框架中，数据库操作的锁和查询类型对于保证数据一致性至关重要。Hibernate作为SSH三大Web开发框架之一，提供了一种便捷的方式来处理数据库交互。本文将深入探讨Hibernate中的锁机制以及不同类型的...
hibernate5_ManyToMany多对多单向维护
01-08
hibernate5_ManyToMany多对多单向维护 hibernate5_ManyToMany多对多单向维护
Hibernate的悲观锁和乐观锁（1）
猎人在吃肉
11-30 396
Hibernate支持两种锁机制：即通常所说的“悲观锁（Pessimistic Locking）”和 “乐观锁（OptimisticLocking）”。谈到悲观锁和乐观锁，就要谈到数据库的并发问题，数据库的隔离级别越高并发性就越差， 并发性：当前系统进行了序列化后，你读取数据库后，别人查询不了，称为并发性不好。下面说的是悲观锁 悲观锁的实现，通常依赖于数据库机制，在整修过程中将数据库锁定，其它
hibernate的悲观锁和乐观锁
zdd183的博客
07-23 140
一、hibernate的锁机制 多个用户可能同时读取同一个数据。为了保证 数据的一致性，需要一种机制来保障其他的程序在这一时刻不能修改这一数据。即上锁。 hibernate中提供了 两种上锁机制，悲观锁和乐观锁。 二、悲观锁 悲观锁指的是线程对数据被外界修改持保守态度。假定任何时刻存取数据时，都可能有另一个客户也正在存取同一笔数据，为了保持数据被操作的一致性，于是对数据采取了数据库层次的锁...
Hibernate 一对多双向映射及乐观锁使用
weixin_34018169的博客
05-27 62
Hibernate 一对多双向映射及乐观锁使用   在“Hibernate关联关系映射实例速查”一文中，通过myeclipse5.5，快速做出了Hibernate各种映射的示例。时隔快一年了，但是还是有博友向我索要工程源码，很遗憾的是已经找不到了。但找到一了一个测试代码：对双向关联和乐观锁的测试。其实映射类型很多，搞清楚一对多，基本上所有的映射就搞明白了，一对一也是一对多的特例而已，多对多也可...
mysql 41000_MySql错误>超出锁定等待超时;尝试重新启动事务SQLState：41000 VendorError：1205...
weixin_39962125的博客
01-19 829
多年来我一直在研究这个问题,但从来没有能够深入到底.我不知道是什么原因导致这些锁定.错误是：超过锁定等待超时;尝试重新启动事务SQLState：41000 VendorError：1205SQL语句是在事务中运行的单个insert语句.所有刀片都是这种形式,所以没有批量插入,也没有混合模式插入等.INSERT INTO附件(id,entityid,entitytype,addeduserid,de...
Hibernate的锁机制
最新发布
weixin_52457750的博客
10-15 650
Hibernate的锁机制
SQLSTATE[HY000]: General error: 1205 Lock wait timeout exceeded； try restarting transaction
taotie_的博客
02-24 740
今天非常坑，遇到一个没有遇到的问题，记录一下。 在执行一个指令的时候，执行了一个事务， 就是这个事务，平平常常，在今天却给我挖了一个深坑，开始事务之后的一个sql语句，始终没有执行，出现以下错误 百思不得其解，各种百度。总结了以下 1）发生这个问题的原因是，开启了一个事务，没有提交或者回滚。（现在想想，可能在开启事务之后，没有执行完代码，然后我强行结束了指令，导致事务线程一直存在，没有结束）。在下图可以直观的看出。 2）找到问题所在，接下来就是执行杀死线程的命令了，既然没有自动结束线程，那么就需要手动
达内J2EE教程： Hibernate进阶实践——查询缓存与锁机制详解
教程详细讲解了悲观锁和乐观锁的区别，以及在何种情况下选择哪种锁策略。案例5重点展示乐观锁的使用方法和注意事项。 整个教程以实践案例驱动，让学习者通过实际操作掌握Hibernate在J2EE开发中的核心功能，提升开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值