Hibernate 悲观锁和乐观锁详解

首先我们来说下锁（locking）的概念：
这个概念在我们学习多线程的时候曾经接触过，其实这里的锁和多线程里面处理并发的锁是一个道理，都是暴力的把资源归为自己所有。这里我们用到锁的目的就是通过一些机制来保证一些数据在某个操作过程中不会被外界修改，这样的机制，在这里，也就是所谓的“锁”，即给我们选定的目标数据上锁，使其无法被其他程序修改。Hibernate支持两种锁机制：即通常所说的“悲观锁（Pessimistic Locking ）”和“乐观锁（ Optimistic Locking ）”。
悲观锁（Pessimistic Locking）：他是对数据库而言的，数据库悲观了，他感觉每一个对他操作的程序都有可能产生并发。它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。

来看一个最简单的数据库悲观锁：

select * from t_girl for update;

来看一个hibernacle中的悲观锁：

/**
	 * *悲观锁
	 */
	@Test
	public void bgs() {
		Girl g1 = (Girl) session.load(Girl.class, 1,LockMode.UPGRADE);//加锁
		g1.setName("123");
		session.save(g1);
		tx.commit();

控制台输出：

Hibernate: select girl0_.id as id0_0_, girl0_.version as version0_0_, girl0_.name as name0_0_, girl0_.stu_id as stu4_0_0_ from t_girl girl0_ where girl0_.id=? for update

这里hibernate通过for update 实现了悲观锁
Hibernate的加锁模式有：
LockMode.NONE ：无锁机制。
LockMode.WRITE ：Hibernate在 Insert和 Update记录的时候会自动获取。
LockMode.READ ：Hibernate在读取记录的时候会自动获取。

乐观锁（Optimistic Locking）：
相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（Version）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个"version"字段来实现。
　　乐观锁的工作原理：读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。
　实现乐观锁的三种方法：
　1、基于 version
　2、基于timestamp（时间戳）
　3、在老项目上添加乐观锁
　
第一种方法：
1.在对象设置
private int version;并且给与get 和set的方法
2.设置对象配置文件
在id字段后面设置：

注意：1.version必须写在id后面
2.数据库的version不能手动去操作或者不能手动去设置setVersion 否则乐观锁失效

例子：

@Test
	public void version() {
		Configuration cfg = new Configuration().configure();
//		SchemaExport export = new SchemaExport(cfg);
//		export.create(true,true);
		SessionFactory sessionFactory = cfg.buildSessionFactory();
		Session session1 = sessionFactory.openSession();
		Session session2 = sessionFactory.openSession();
		Girl g1 = (Girl) session1.load(Girl.class, 1);
		Girl g2 = (Girl) session2.load(Girl.class, 1);
		//这时候两个版本号是相同的
		System.out.println(g1.getVersion()+"\t"+g2.getVersion());
		Transaction tx1 = session1.beginTransaction();
		g1.setName("张三123456789");
		session1.update(g1);
		tx1.commit();
		//提交了一次事物之后，两个版本号不相同了，g1的版本号递增了
		System.out.println(g1.getVersion()+"\t"+g2.getVersion());
		System.out.println(g2.getName());
		Transaction tx2 = session2.beginTransaction();
		g2.setName("李四11");
		session2.update(g2);
		tx2.commit();		
	}

控制台输出：

Hibernate: select girl0_.id as id4_0_, girl0_.version as version4_0_, girl0_.name as name4_0_, girl0_.stu_id as stu4_4_0_ from t_girl girl0_ where girl0_.id=?
Hibernate: select girl0_.id as id4_0_, girl0_.version as version4_0_, girl0_.name as name4_0_, girl0_.stu_id as stu4_4_0_ from t_girl girl0_ where girl0_.id=?
13	13
Hibernate: update t_girl set version=?, name=?, stu_id=? where id=? and version=?
14	13
123
Hibernate: update t_girl set version=?, name=?, stu_id=? where id=? and version=?

单元测试：

org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [com.hxzy.hibernate.entity.Girl#1]

第一次修改的时候版本号相同，所以修改成功了，第二次修改的时候，g1的版本号递增了，所以修改失败了，单元测试报出错误。

第二种方法：
1.在对象设置

private Timestamp timestamp;  //java.sql.Timestamp

2.设置对象配置文件

第三种方法：

这种方法主要是用在老项目添加乐观锁
在对象配置文件上设置

optimistic-lock = true

总结：
乐观锁和悲观锁区别：
1.乐观锁主要借助于version
2.悲观锁主要借助于数据库锁

使用悲观锁时，会悲观锁定当前数据或对象，在当前事务操作完成之前，其它人无法对这些数据进行操作。
相当于select * from t_user for update
设置 session.load(studnet,1,LockMode.UPGRADE); 在hibernate3.6之前可以进行悲观锁定

使用乐观锁参照前面的3种设置方法，只要当前versionid一直就没问题，如果有且并发有一个version提交version+1；如果并发
发现两个version不一致就会抛出异常。