`
lovnet
  • 浏览: 6764926 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
文章分类
社区版块
存档分类
最新评论

hibernate 控制并发访问

 
阅读更多
在标准SQL规范中，定义了4个事务隔离级别，不同的隔离级别对事务的处理不同:
◆未授权读取（Read Uncommitted）：允许脏读取，但不允许更新丢失。如果一个事务已经开始写数据，则另外一个数据则不允许同时进行写操作，但允许其他事务读此行数据。该隔离级别可以通过“排他写锁”实现。

◆授权读取（Read Committed）：允许不可重复读取，但不允许脏读取。这可以通过“瞬间共享读锁”和“排他写锁”实现。读取数据的事务允许其他事务继续访问该行数据，但是未提交的写事务将会禁止其他事务访问该行。

◆可重复读取（Repeatable Read）：禁止不可重复读取和脏读取，但是有时可能出现幻影数据。这可以通过“共享读锁”和“排他写锁”实现。读取数据的事务将会禁止写事务（但允许读事务），写事务则禁止任何其他事务。

◆序列化（Serializable）：提供严格的事务隔离。它要求事务序列化执行，事务只能一个接着一个地执行，但不能并发执行。如果仅仅通过“行级锁”是无法实现事务序列化的，必须通过其他机制保证新插入的数据不会被刚执行查询操作的事务访问到。


如果一个事务读取由另一个还没有被提交的事务进行的改变，就发生脏读取（dirty read）。这很危险，因为由其他事务进行的改变随后
可能回滚，并且低一个事务可能编写无效的数据。

如果一个事物读取一个行两次，并且每次读取不同的状态，就会发生不可重复读取（unrepeatable read）。例如，另一个事务可能已经
写到这个行，并已经在两次读取之间提交。

不可重复读取的一个特殊案例是二次丢失更新问题（second lost updates problem）。想象两个并发事务都读取一个行：一个写到行并
提交，然后第二个也写到行并提交。有第一个事务所做的改变丢失了。

幻读（phantom read）发生在一个事务执行一个查询两次，并且第二个结果集包括第一个结果集中不可见的行，或者包括已经删除的行时。
这种情况是由另一个事务在两次查询执行之间插入或者删除行照成的。


ANSI事务隔离性级别：
允许脏读取但不允许丢失更新的系统，要在读取未提交（read uncommitted）的隔离性中操作。如果一个为提交事务已经写到一个行，
另一个事务就不可能再写到这个行。但任何事务都可以读取任何行。这个隔离性级别可以在数据库管理系统中通过专门的写锁来实现。

允许不可重复读取但不允许脏读取系统，要实现读取提交（read committed）的事务隔离性。这可以用共享的读锁和专门的写锁来实现。
读取事务不会阻塞其他事务访问行。但是为提交的鞋事务隔赛所有其他的事务访问改行。

在可重复读（repeatable read）隔离性模式中操作的系统既不允许不可重复读取，也不允许脏读取。幻读可能发生。

可序列化 （serializable）提供最严格的事务隔离性。这个隔离性级别模拟连续的事务执行，好像事务是连续的一个接一个的执行，而不是
并发的执行。




选择隔离性级别：
首先，消除读取为提交隔离性级别。在不同的事务中使用一个为提交的事务变化是很危险的。一个事务的回滚或者失败将影响其他的并发事务。
甚至由一个终止回滚的事务所做的改变也可能在任何地方被提交，因为他们可能读取，然后由另一个成功的事务传播！
其次，大多数应用程序不需要可序列化的隔离级别（幻读通常不成问题），并且这个隔离性往往难以伸缩。
这样就把选择读取提交还是可重复读取交给你了。






Hibernate配置选项：
hibernate.connection.isolation = 4
1-读取为提交隔离性
2-读取提交隔离性
3-可重复读取隔离性
4-可序列化隔离性







乐观并发控制：
乐观的方法始终假设一切都会很好，并且很少有冲突的数据修改。在编写数据时，乐观并发控制值在工作单元结束时才出现错误。多用户
的应用程序通常默认为使用读取提交隔离性级别的乐观并发控制和数据库连接。只有适当的时候才获得额外的隔离性保证；这种方法保证
了最佳的性能和可伸缩性。


对于如何处理对话中这些第二个事务中的丢失更新，你有3种选择：
最晚提交生效（last commit wins）--两个事物提交都成功，第二个提交覆盖第一个变化。没有显示错误消息。
最早提交生效（fist commit wins）--对话A的事务被提交，并且在对话B中提交事务的用户得到一条错误信息。用户必须获取新数据来
重启会话，并在此利用没有失效的数据完成对话的所有步骤。
合并冲突更新（merge conflicting updates）--第一个修改被提交，并且对话B中的事务在提交时终止，带有一条错误消息。但是失败
的对话B用户可以选择性的应用变化，而不是再次在对话中完成所有工作。





在hibernate中启用版本控制：
hibernate提供自动的版本控制。每个实体实例都有一个版本，它可以是一个数字或者是一个时间戳。当对象修改时，hibernate就增加
他的版本号，自动比较版本，如果侦测到冲突就抛出异常。因此，你给所有持久化的实体类都添加这个版本属性，来启动乐观锁：
version：
view plaincopy to clipboardprint?
  1. publicclassItemimplementsSerializable {
  2. privateInteger itemId;
  3. privateString itemName;
  5. /** 版本控制 */
  6. privateintversion;

配置：
view plaincopy to clipboardprint?
  1. <classname="Item"table="ITEM">
  2. <id name="itemId"column="ITEM_ID"type="integer">
  3. <generatorclass="native"/>
  4. </id>
  5. <!-- XML格式的version属性映射必须立即放在标示符属性映射之后 -->
  6. <version name="version"access="field"column="OBJ_VERSION"/>
  8. <property name="itemName"type="string"column="ITEM_NAME"/>
  10. </class>

代码：
view plaincopy to clipboardprint?
  1. /**
  2. * 报错：
  3. * org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)
  4. * @param itemName
  5. */
  6. privatestaticvoidupdate1(String itemName) {
  7. Configuration configuration =newConfiguration().configure();
  8. SessionFactory sessionFactory = configuration.buildSessionFactory();
  9. Session session = sessionFactory.openSession();
  10. Transaction tr = session.beginTransaction();
  12. Item item = (Item) session.get(Item.class,1);
  13. item.setItemName(itemName);
  16. Session session1 = sessionFactory.openSession();
  17. Transaction tr1 = session1.beginTransaction();
  19. Item item1 = (Item) session1.get(Item.class,1);
  20. //一样会报错
  21. //item1.setItemName(itemName);
  23. item1.setItemName(itemName+"1");
  26. tr.commit();
  27. session.close();
  29. //org.hibernate.StaleObjectStateException:
  30. //Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)
  31. tr1.commit();
  32. session1.close();
  34. sessionFactory.close();
  35. }
  38. /**
  39. * 提交成功
  40. * @param itemName
  41. */
  42. privatestaticvoidupdate2(String itemName) {
  43. Configuration configuration =newConfiguration().configure();
  44. SessionFactory sessionFactory = configuration.buildSessionFactory();
  45. Session session = sessionFactory.openSession();
  46. Transaction tr = session.beginTransaction();
  48. Item item = (Item) session.get(Item.class,1);
  49. item.setItemName(itemName);
  51. tr.commit();
  52. session.close();
  54. Session session1 = sessionFactory.openSession();
  55. Transaction tr1 = session1.beginTransaction();
  57. Item item1 = (Item) session1.get(Item.class,1);
  58. item1.setItemName(itemName+"1");
  60. tr1.commit();
  61. session1.close();
  63. sessionFactory.close();
  64. }


timestamp（理论上讲，时间戳更不安全。且在集群环境中更不安全）:
view plaincopy to clipboardprint?
  1. publicclassItemimplementsSerializable {
  2. privateInteger itemId;
  3. privateString itemName;
  5. /** 版本控制 */
  6. privateDate lastUpdated;

配置：
view plaincopy to clipboardprint?
  1. <classname="Item"table="ITEM">
  2. <id name="itemId"column="ITEM_ID"type="integer">
  3. <generatorclass="native"/>
  4. </id>
  5. <timestamp name="lastUpdated"access="field"column="LAST_UPDATED"></timestamp>
  7. <property name="itemName"type="string"column="ITEM_NAME"/>
  9. </class>

代码：
view plaincopy to clipboardprint?
  1. /**
  2. * 报错：
  3. * org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)
  4. * @param itemName
  5. */
  6. privatestaticvoidupdate1(String itemName) {
  7. Configuration configuration =newConfiguration().configure();
  8. SessionFactory sessionFactory = configuration.buildSessionFactory();
  9. Session session = sessionFactory.openSession();
  10. Transaction tr = session.beginTransaction();
  12. Item item = (Item) session.get(Item.class,1);
  13. item.setItemName(itemName);
  16. Session session1 = sessionFactory.openSession();
  17. Transaction tr1 = session1.beginTransaction();
  19. Item item1 = (Item) session1.get(Item.class,1);
  20. //一样会报错
  21. //item1.setItemName(itemName);
  23. item1.setItemName(itemName+"1");
  26. tr.commit();
  27. session.close();
  29. //org.hibernate.StaleObjectStateException:
  30. //Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect)
  31. tr1.commit();
  32. session1.close();
  34. sessionFactory.close();
  35. }
  38. /**
  39. * 提交成功
  40. * @param itemName
  41. */
  42. privatestaticvoidupdate2(String itemName) {
  43. Configuration configuration =newConfiguration().configure();
  44. SessionFactory sessionFactory = configuration.buildSessionFactory();
  45. Session session = sessionFactory.openSession();
  46. Transaction tr = session.beginTransaction();
  48. Item item = (Item) session.get(Item.class,1);
  49. item.setItemName(itemName);
  51. tr.commit();
  52. session.close();
  54. Session session1 = sessionFactory.openSession();
  55. Transaction tr1 = session1.beginTransaction();
  57. Item item1 = (Item) session1.get(Item.class,1);
  58. item1.setItemName(itemName+"1");
  60. tr1.commit();
  61. session1.close();
  63. sessionFactory.close();
  64. }



hibernate检查机制：
org.hibernate.persister.entity.AbstractEntityPersister.check：
view plaincopy to clipboardprint?
  1. protectedbooleancheck(introws, Serializable id,inttableNumber, Expectation expectation, PreparedStatement statement)throwsHibernateException {
  2. try{
  3. expectation.verifyOutcome( rows, statement, -1);
  4. }
  5. catch( StaleStateException e ) {
  6. if( !isNullableTable( tableNumber ) ) {
  7. if( getFactory().getStatistics().isStatisticsEnabled() ) {
  8. getFactory().getStatisticsImplementor()
  9. .optimisticFailure( getEntityName() );
  10. }
  11. thrownewStaleObjectStateException( getEntityName(), id );
  12. }
  13. returnfalse;
  14. }
  15. catch( TooManyRowsAffectedException e ) {
  16. thrownewHibernateException(
  17. "Duplicate identifier in table for: "+
  18. MessageHelper.infoString(this, id, getFactory() )
  19. );
  20. }
  21. catch( Throwable t ) {
  22. returnfalse;
  23. }
  24. returntrue;
  25. }

org.hibernate.jdbc.Expectation：
view plaincopy to clipboardprint?
  1. /**
  2. * Perform verification of the outcome of the RDBMS operation based on
  3. * the type of expectation defined.
  4. *
  5. * @param rowCount The RDBMS reported "number of rows affected".
  6. * @param statement The statement representing the operation
  7. * @param batchPosition The position in the batch (if batching)
  8. * @throws SQLException Exception from the JDBC driver
  9. * @throws HibernateException Problem processing the outcome.
  10. */
  11. publicvoidverifyOutcome(introwCount, PreparedStatement statement,intbatchPosition)throwsSQLException, HibernateException;
view plaincopy to clipboardprint?
  1. /**
  2. * 我用了两个factory，也是可以提交成功的
  3. * 你想想，这证明了什么
  4. * @param itemName
  5. */
  6. privatestaticvoidupdate3(String itemName) {
  7. Configuration configuration =newConfiguration().configure();
  8. SessionFactory sessionFactory = configuration.buildSessionFactory();
  9. Session session = sessionFactory.openSession();
  10. Transaction tr = session.beginTransaction();
  12. Item item = (Item) session.get(Item.class,1);
  13. item.setItemName(itemName);
  15. tr.commit();
  16. session.close();
  18. sessionFactory.close();
  21. Configuration configuration1 =newConfiguration().configure();
  22. SessionFactory sessionFactory1 = configuration1.buildSessionFactory();
  23. Session session1 = sessionFactory1.openSession();
  24. Transaction tr1 = session1.beginTransaction();
  26. Item item1 = (Item) session1.get(Item.class,1);
  27. item1.setItemName(itemName+"11");
  29. tr1.commit();
  30. session1.close();
  32. sessionFactory1.close();
  33. }



版本控制的自动管理：
涉及目前被版本控制的Item对象的每一个DML操作都包括版本检查。例如，假设在一个工作单元中，你从版本为1的数据库中加载一个Item。然后修改它的其中一个值类型属性。当持久化
上下文被清除时，hibernate侦测到修改，并把Item的版本增加到2。然后执行SQL UPDATE使这一修改在数据库中永久化：
update item set intial_price = '11.23',obj_version=2 where item_id = 123 and obj_version=1
如果另一个并发的工作单元更新和提交了同一个行，obj_version列就不包含值1，行也不会被更新。hibernate检查由jdbc驱动器返回这个语句所更新
的行数---在这个例子中，被更新的行数为0--并抛出StaleObjectStateException。加载Item时呈现的状态，清除时不再在数据库中呈现；
因而，你真正使用失效的数据，必须通知应用程序的用户。可以捕捉这个异常，并显示一条错误消息，或者显示帮助用户给应用程序重启会话
的一个提示框。
如果你想要禁用对特定值类型属性或者集合的自动增加，就用optimistic-lock="false"属性映射他。







没有版本号或者时间戳的版本控制（如果你用的遗留表，不方便再添加字段）：
view plaincopy to clipboardprint?
  1. <!-- org.hibernate.MappingException: optimistic-lock=all|dirty requires dynamic-update="true"-->
  2. <!-- dirty的区别在于，只有当某个属性共同修改时，才报错；all是只要有修改就报错 -->
  3. <classname="Item"table="ITEM"optimistic-lock="all"dynamic-update="true">
  4. <id name="itemId"column="ITEM_ID"type="integer">
  5. <generatorclass="native"/>
  6. </id>
  8. <property name="itemName"type="string"column="ITEM_NAME"/>
  10. </class>






用Java Persistence版本控制：
version:
实体：
view plaincopy to clipboardprint?
  1. @Entity
  2. publicclassItemimplementsSerializable {
  3. @Id
  4. @GeneratedValue
  5. @Column(name="ITEM_ID")
  6. privateInteger itemId;
  7. @Column(name="ITEM_NAME")
  8. privateString itemName;
  10. /** 版本控制 */
  11. @Version
  12. @Column(name="OBJ_VERSION")
  13. privateintversion;

更新：
view plaincopy to clipboardprint?
  1. privatestaticvoidupdate(String itemName) {
  2. EntityManagerFactory factory = Persistence.createEntityManagerFactory("partner4java");
  3. EntityManager em = factory.createEntityManager();
  4. EntityTransaction tr = em.getTransaction();
  5. tr.begin();
  7. Item item = em.find(Item.class,1);
  8. item.setItemName(itemName);
  10. EntityManager em1 = factory.createEntityManager();
  11. EntityTransaction tr1 = em1.getTransaction();
  12. tr1.begin();
  14. Item item1 = em1.find(Item.class,1);
  15. item1.setItemName(itemName+"he");
  17. tr.commit();
  18. em.close();
  19. //Caused by: javax.persistence.OptimisticLockException
  20. tr1.commit();
  21. em1.close();
  22. factory.close();
  23. }

报错：
Caused by: javax.persistence.OptimisticLockException

optimisticLock:
实体：
view plaincopy to clipboardprint?
  1. @Entity
  2. //optimistic-lock=all|dirty requires dynamic-update="true"
  3. @org.hibernate.annotations.Entity(
  4. optimisticLock=OptimisticLockType.ALL,
  5. dynamicUpdate=true)
  6. publicclassItemimplementsSerializable {
  7. @Id
  8. @GeneratedValue
  9. @Column(name="ITEM_ID")
  10. privateInteger itemId;
  11. @Column(name="ITEM_NAME")
  12. privateString itemName;
  14. //版本检测排除下面的属性
  15. @OptimisticLock(excluded=true)
  16. privateDouble price;
  18. publicItem() {
  19. super();
  20. }

调用：
view plaincopy to clipboardprint?
  1. /**
  2. * 报错
  3. * Caused by: javax.persistence.OptimisticLockException
  4. * @param itemName
  5. */
  6. privatestaticvoidupdate1(String itemName) {
  7. EntityManagerFactory factory = Persistence.createEntityManagerFactory("partner4java");
  8. EntityManager em = factory.createEntityManager();
  9. EntityTransaction tr = em.getTransaction();
  10. tr.begin();
  12. Item item = em.find(Item.class,1);
  13. item.setItemName(itemName);
  15. EntityManager em1 = factory.createEntityManager();
  16. EntityTransaction tr1 = em1.getTransaction();
  17. tr1.begin();
  19. Item item1 = em1.find(Item.class,1);
  20. item1.setItemName(itemName+"he");
  22. tr.commit();
  23. em.close();
  24. //Caused by: javax.persistence.OptimisticLockException
  25. tr1.commit();
  26. em1.close();
  27. factory.close();
  28. }
  30. /**
  31. * 不会报错
  32. * @param price
  33. */
  34. privatestaticvoidupdate2(Double price) {
  35. EntityManagerFactory factory = Persistence.createEntityManagerFactory("partner4java");
  36. EntityManager em = factory.createEntityManager();
  37. EntityTransaction tr = em.getTransaction();
  38. tr.begin();
  40. Item item = em.find(Item.class,1);
  41. item.setPrice(price);
  43. EntityManager em1 = factory.createEntityManager();
  44. EntityTransaction tr1 = em1.getTransaction();
  45. tr1.begin();
  47. Item item1 = em1.find(Item.class,1);
  48. item1.setPrice(price+1D);
  50. tr.commit();
  51. em.close();
  52. tr1.commit();
  53. em1.close();
  54. factory.close();
  55. }








获得额外的隔离性保证：
1、显示的悲观锁
当我们关注应用程序的课伸缩性时。例如，对标量查询可能需要可重复读取。
不是把所有的数据库事务转换为一个更高的、不可伸缩的隔离性级别，而是在必要时，在Hibernate Session中使用lock()方法获得
更高的隔离性：
view plaincopy to clipboardprint?
  1. /**
  2. * session.lock(item, LockMode.UPGRADE);
  3. * @param itemName
  4. */
  5. privatestaticvoidupdate1(String itemName) {
  6. Configuration configuration =newConfiguration().configure();
  7. SessionFactory sessionFactory = configuration.buildSessionFactory();
  8. Session session = sessionFactory.openSession();
  9. Transaction tr = session.beginTransaction();
  11. Item item = (Item) session.get(Item.class,1);
  12. item.setItemName(itemName);
  14. //指定锁级别
  15. session.lock(item, LockMode.UPGRADE);
  18. Session session1 = sessionFactory.openSession();
  19. Transaction tr1 = session1.beginTransaction();
  20. Item item1 = (Item) session1.get(Item.class,1);
  21. item1.setItemName(itemName+"1");
  23. //停在这步，因为碰到for update的锁了，他要等到tr提交了之后才会执行，但是，我们这个demo当然无法执行到这步
  24. tr1.commit();
  25. session1.close();
  27. tr.commit();
  28. session.close();
  30. sessionFactory.close();
  31. }
  34. /**
  35. * 只锁定指定列的数据,不会锁定表
  36. * 但是，以前这种方式是悲观锁，会锁定整个表，如果指定锁定某一行，如下：
  37. * Item item = (Item) session.get(Item.class, 1, LockMode.UPGRADE);
  38. * @param itemName
  39. */
  40. privatestaticvoidupdate2(String itemName) {
  41. Configuration configuration =newConfiguration().configure();
  42. SessionFactory sessionFactory = configuration.buildSessionFactory();
  43. Session session = sessionFactory.openSession();
  44. Transaction tr = session.beginTransaction();
  46. Item item = (Item) session.get(Item.class,1);
  47. item.setItemName(itemName);
  49. //指定锁级别
  50. session.lock(item, LockMode.UPGRADE);
  53. Session session1 = sessionFactory.openSession();
  54. Transaction tr1 = session1.beginTransaction();
  55. Item item1 = (Item) session1.get(Item.class,2);
  56. item1.setItemName(itemName+"1");
  58. //执行通过
  59. tr1.commit();
  60. session1.close();
  62. tr.commit();
  63. session.close();
  65. sessionFactory.close();
  66. }


Java Persistence 的hibernate也实现了这个技术，但是规范并没有要求实现这个。




hibernate锁模式：
LockMode.NONE--别到数据库中去，除非对象不处于任何高速缓存中。
LockMode.READ--绕过所有高速缓存，并执行版本检查，来验证内存中的对象是否与当前数据中村中的版本相同。
LockMode.UPGRADE--绕过所有高速缓存，做一个版本检查，如果支持的话，就获得数据库级的悲观升级锁。相当于Java Persistence中的LockModeType.READ。如果数据库方言不支持
select...for update选项，这个模式就透明的退回到LockMode.READ。
LockMode.UPGRADE_NOWAIT--与LockMode.UPGRADE相同，但如果支持的话，就使用select...for update nowait。他禁用了等待并发所释放，因为如果无法获得锁，就立即抛出锁异常。
如果数据库SQL方言不支持nowait选择，这个模式就透明的退回到LockMode.UPGRADE。
LockMode.FORCE--在数据库中强制增加对象的版本，来表明他已经被当前事务修改。相当于Java Persistence中的LockModeType.WRITE。
LockMode.WRITE--当hibernate已经在当前事务中写到一个行时，就自动获得他。（内部模式）

默认情况下load()和get()使用NONE。





分享到：
| VC 运行时库中的 new/delete 函数
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate事务和并发控制

    至于并发控制，主要目的是解决多用户同时访问同一数据时可能出现的问题，如脏读、不可重复读和幻读等。在数据库层面，常见的并发控制机制包括锁和乐观锁。Hibernate提供了多种并发策略，如版本字段（version）和...

    Hibernate 事务和并发控制

    本文将深入探讨Hibernate中的事务和并发控制，这对于开发高效、稳定的数据库应用至关重要。 首先，我们来理解Hibernate中的事务管理。在数据库操作中，事务是保证数据一致性的重要手段。一个事务包含了一组数据库...

    hibernate事务,并发及缓存管理实例

    在Hibernate中，事务、并发控制和缓存管理是至关重要的概念，它们极大地影响了应用程序的性能和数据一致性。 一、Hibernate事务管理 在数据库操作中，事务确保了数据的一致性和完整性。Hibernate提供了四种事务隔离...

    Hibernate事务与并发问题处理.pdf

    以下是关于Hibernate事务和并发控制的详细讨论。 1. **数据库事务的定义** 数据库事务是一系列操作的逻辑单位，这些操作要么全部成功，要么全部失败。事务满足ACID属性： - **原子性**（Atomicity）：事务中的...

    课程hibernate的事务和并发.pdf

    《课程hibernate的事务和并发》主要探讨了在Hibernate框架中如何管理和处理事务以及并发控制。Hibernate作为一款流行的Java ORM（对象关系映射）工具，其事务处理和并发控制策略对于开发高效、稳定的数据库应用至关...

    hibernate的事务和并发资料.pdf

    《Hibernate的事务和并发资料》深入探讨了在Java应用程序中使用Hibernate进行事务管理和并发控制的关键概念。Hibernate作为一款流行的ORM框架，它简化了与数据库的交互，但同时也需要开发者理解其背后的事务处理机制...

    hibernate源码分析过程

    数据版本并发性控制可以使用版本、时间戳等方式来控制并发访问。 集合映射 Hibernate 的集合映射可以将一个对象的集合属性映射到数据库中。集合映射可以是 set、list、map、bag、array 等。级联策略控制可以控制...

    Spring控制Hibernate中的事务传播特性与隔离级别操作.docx

    在Spring框架中，为了管理和控制Hibernate事务，Spring提供了两种关键工具：HibernateTemplate和JdbcTemplate。这两个模板类简化了与数据库的交互，同时也处理了事务管理。让我们深入了解一下这两个类以及它们如何...

    hibernate一级缓存和二级缓存的区别与联系

    二级缓存可以通过设置不同的并发访问策略来解决并发问题，如事务型、读写型或非严格读写型，以适应不同场景下的需求。 持久化层的缓存范围决定了缓存的生命周期和访问权限。事务范围的缓存最安全，但只限于当前事务...

    J2EE事务并发控制策略总结汇编.pdf

    事务并发访问控制分为两类：同一系统事务内的并发控制和跨系统事务的并发控制。在讨论具体策略之前，首先需要理解数据库事务的四种隔离级别。 1. 读取未提交（Read Uncommitted）：这是最低的隔离级别，允许脏读，...

    精通hibernate

    Hibernate支持乐观锁和悲观锁机制，处理多用户并发访问同一数据时可能出现的问题。乐观锁假设并发冲突较少，而在数据更新时检查版本号；悲观锁则在读取数据时就加锁，防止其他用户修改。 五、缓存与性能优化 1. 第...

    memcache也spring,hibernate的配置

    8. **实际应用**：这种配置适用于高并发、读多写少的Web应用，例如电子商务网站的商品详情页，通过缓存减少对数据库的频繁访问，提高响应速度。 综上所述，这个项目展示了如何在Java环境下，利用Maven构建工具，将...

    Hibernate的缓存机制

    本文将深入探讨 Hibernate 的缓存机制，包括其两个级别——一级缓存和二级缓存，并讨论它们的工作原理、范围、并发访问策略以及如何管理和配置。 1. **一级缓存** - **范围与作用**：一级缓存是 Session 级别的...

    HIBERNATE官方参考手册

    20. **实体的版本控制（Versioning）**：通过乐观锁或悲观锁实现并发控制，防止数据冲突。 通过深入阅读《Hibernate官方参考手册》，开发者可以全面掌握Hibernate的使用方法，从而高效地开发Java应用程序的数据访问...

    Hibernate四大属性

    C3P0是常用的数据库连接池实现，它可以管理数据库连接的生命周期，提供并发访问的高效性。`min_size`值决定了当连接池空闲时，最少保持的连接数量，以应对可能的并发请求。 这四个属性是Hibernate配置的核心部分，...

    精通Hibernate(孙卫琴)

    同时，他还探讨了事务管理和并发控制，这些都是确保数据一致性和完整性的关键。 最后，书中的实战案例部分，通过实际项目的开发过程，帮助读者将理论知识应用到实践中，增强了解决问题的能力。这些案例涵盖了常见的...

    Hibernate说明

    Hibernate支持JTA（Java Transaction API）和JDBC事务，通过Transaction对象进行控制，保证数据的一致性和完整性。 八、高级特性 1. 异步操作：使用Hibernate的异步API，提高应用性能。 2. 批量操作：如批处理更新...

    hibernate的一级缓存和二级缓存

    二级缓存需要提供并发访问策略以确保事务隔离级别，同时也需要设定数据过期策略，如最大内存数量、存活时间等，以防止缓存数据过时或占用过多资源。二级缓存还可以将超出内存限制的数据写入硬盘，形成持久化的缓存。...

    hibernate源码

    此外，Hibernate还提供了乐观锁和悲观锁策略，用于并发控制。 七、延迟加载（Lazy Loading） 延迟加载是Hibernate的一个重要特性，它只在真正需要时才加载关联对象，从而避免了大量无谓的数据获取。这种机制依赖于...

    hibernate源码release-4.1.4.Final版

    它通过提供对象化的数据访问接口，使得开发者可以更加专注于业务逻辑，而无需过多地关注底层SQL语句的编写。本篇文章将围绕Hibernate 4.1.4.Final版本的源码进行深入探讨，揭示其内部机制，帮助读者提升对Hibernate...

Magicbox
Global site tag (gtag.js) - Google Analytics