【Hibernate】Hibernate中的悲观锁和乐观锁

一，锁的产生？

    因为数据库是一个多用户的共享资源，当很多用户同时操作一条数据的时候，如果对这种操作不加以控制，就会产生读取和存取不一致的情况，破坏数据库的一致性。在多个用户中，在同一个时间可能会有多个用户更新使用相同的记录，这就会产生冲突。所以为了防止大家同一时间对于同一条数据的操作，就有了加锁的方式。

二，何谓悲观锁和乐观锁

      悲观锁，理解为一个人很悲观，每次去拿数据的时候，都认为别人会修改。为了不让别人修改，所以每次拿数据的时候，都会上锁，这样别人使用这个数据的时候都得等着。直到这个悲观的人使用完成之后，他才会解锁，别人才能够使用。

     乐观锁，理解为一个人很乐观，每次去拿数据的时候，认为别人不会修改，所以不会上锁。但是在更新时候，会判断一下别人有没有更新这个数据，可以使用版本号等机制。

     两种锁各有优缺点，不能够认为一种优于另一种。在实际的环境中，如果并发量不是很大并且不允许脏读，可以使用悲观锁来解决并发问题。但是如果系统的并发量很大，很多用户同时访问，悲观锁就会降低访问效率，所以选择乐观锁的方法更好。

三、业务场景

现在有一个仓库用来存放奶粉，用户一和用户二是两个仓库管理员。刚开始仓库中有编号1001的三鹿奶粉1000罐，两个用户现在都要拿走200罐奶粉的操作。接下来，就来模拟一下乐观锁和悲观锁在相同场景下的不同解决方式。

1，新建清单类

package com.bjpowernode.hibernate;

public class Inventory {

	private String itemNo;
	
	private String itemName;
	
	private int quantity;
	
	//乐观锁需要使用版本号，悲观锁可以忽略
	private int version;
         .......接着为每个属性生成get和set方法，省略
	
}

2，配置Inventory.hbm.xml文件

<?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.bjpowernode.hibernate.Inventory" table="t_inventory" >
		<id name="itemNo">
			<generator class="assigned"/>
		</id>
		<property name="itemName"/>
		<property name="quantity"/>
	</class>
</hibernate-mapping>

3，在hibernate.cfg.xml中配置

<!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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_beiguan_locking?characterEncoding=UTF-8</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">1</property>
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="hibernate.show_sql">true</property>
		<!-- //映射文件 -->
		<mapping resource="com/bjpowernode/hibernate/Inventory.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

4，生成表并且向数据库中添加一条数据。

          

5，悲观锁应用

使用机制：在加载数据时，就要锁住，通常采用for update语句，一般使用LockMode.UPGRADE模式。如果使用悲观锁，那么懒加载无效。

          

模拟用户一和用户二取200罐奶粉的操作。

package com.bjpowernode.hibernate;
import org.hibernate.LockMode;
import org.hibernate.Session;
import junit.framework.TestCase;
public class OptimisticLockingTest extends TestCase {

	/*
	 * 用户一执行执行取200奶粉操作
	 */
	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			Inventory inv = (Inventory)session.load(Inventory.class, "1001");
			System.out.println("opt1-->itemNo=" + inv.getItemNo());
			System.out.println("opt1-->itemName=" + inv.getItemName());
			System.out.println("opt1-->version=" + inv.getVersion());
			System.out.println("opt1-->quantity=" + inv.getQuantity());
			//奶粉数量减去200，变成了800
			inv.setQuantity(inv.getQuantity() - 200);
			//事务提交
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}
	
	/*
	 * 用户二同时执行取奶粉操作
	 */
	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();
			//读取奶粉数量仍然是1000，并且检测到有人在操作，并且被上锁，所以停止操作，等待。
			Inventory inv = (Inventory)session.load(Inventory.class, "1001");
			System.out.println("opt2-->itemNo=" + inv.getItemNo());
			System.out.println("opt2-->itemName=" + inv.getItemName());
			System.out.println("opt2-->version=" + inv.getVersion());
			System.out.println("opt2-->quantity=" + inv.getQuantity());
			//用户1操作完成之后，然后读取数量800，然后减去200，变成了600，然后提交
			inv.setQuantity(inv.getQuantity() - 200);
			
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}			
}

接下来我们用Debug方式来模拟用户的操作。

第一步，用户一执行Debug模式，查询到数据之后，利用Hibernate的LockModel.UPGRADE,将奶粉这条记录锁住，将执行：

select inventory0_.itemNo as itemNo0_0_, inventory0_.version as version0_0_, inventory0_.itemName as itemName0_0_, inventory0_.quantity as quantity0_0_ from t_inventory inventory0_ where inventory0_.itemNo=? for update这句话。

打印出相应奶粉数量，别的用户不能够操作。现在数量减去了200 ，但是还未提交，所以这条记录处于加锁的状态，别的用户不能够操作。

第二步：用户二执行

现在第二个用户来了，执行testload2方法，也想减去200奶粉。检测到用户一还没有执行完，这条记录被上锁资源还没有被释放，就得等着。超过时间则会报错。

Lock wait timeout exceeded; try restarting transaction
主要原因是：

锁等待超时。是当前事务在等待其它事务释放锁资源造成的org.hibernate.exception.GenericJDBCException: could not update: [com.bjpowernode.hibernate.Inventory#1001]

第三步：用户一执行完成，用户二读取到了800

session.getTransaction().commit();

提交事务，本条记录解锁，释放资源。此时奶粉数量=1000-200=800。用户二读取到800，然后减去200，此时数量变成了600.

这就是通过Debug模式，通过两个用户 模拟的悲观锁的执行情况。

6，乐观锁应用
（1）运行机制：更新的时候，查询版本号是否是最新的，如果版本低于现在最新的，那么就不让修改,

（2）Hibernate如何支持乐观锁：
大多数的使用时采用数据版本的方式，一般在数据库中加入一个叫Version的字段。在读取数据的时候，将Version读取出来，在保存数据的时候，判断Version的值是否小于数据库中的Version值，如果小于，那么不予更新。
（3）基本类和悲观锁大体一致，不一致配置如下

第一：Inventory.hbm.xml文件中添加乐观锁的方式：

<hibernate-mapping>
<!-- optimistic-lock="version" 乐观锁的时候用到 -->
	<class name="com.bjpowernode.hibernate.Inventory" table="t_inventory" optimistic-lock="version">
		<id name="itemNo">
			<generator class="assigned"/>
		</id>
		<version name="version"/> <!-- 配置版本， -->
		<property name="itemName"/>
		<property name="quantity"/>
	</class>
</hibernate-mapping>

第二：测试类中执行完成，不加锁。

接下来通过User3和User4来模拟乐观锁的执行情况

第一步：User3执行到一半停止

User3Debug运行到提交之前，将数量减去了200，打印出相应的奶粉信息。事务未提交之前，版本号为0。此时用户3停止操作，去看会电视剧。

第二步：用户4执行奶粉数量减去200的操作。

用户4读取的数量是1000，执行减去200操作，更新数据库。打印相关的奶粉信息如下：

此时数据库中的版本号变成了1，数量成为800.

第三步：User3继续执行

user3玩儿回来了，继续执行减去200的操作，在Commit之前，检测一下版本是否还是0，但是发现版本变成了1，就报错了，不予更新。报错如下：

   Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): 
  [com.bjpowernode.hibernate.Inventory#1001]

说明：操作的对象应用了乐观锁机制，当版本不一致时，将出现问题。

小结：

    I want  to write a lot,but I can't express myself well.