Hibernate 事务的并发处理
事务定义：数据库事务是指由一个或多个SQL语句组成的工作单元，这个工作单元中的SQL语句相互依赖，如果有一个SQL语句执行失败，就必须撤销整个工作单元。事务的特性ACID：原子性，一致性，独立性，持久性
?
事务可能出现的问题：?
处理这些问题的解决方案，就是事务的隔离机制：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 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;@BeforeClasspublic static void beforeClass() {sf = new AnnotationConfiguration().configure().buildSessionFactory();}@AfterClasspublic static void afterClass() {sf.close();}@Testpublic void testSchemaExport() {new SchemaExport(new AnnotationConfiguration().configure()).create(false, true);}@Testpublic void testSave() {Session session = sf.openSession();session.beginTransaction();Account a = new Account();a.setBalance(100);session.save(a);session.getTransaction().commit();session.close();}//测试乐观锁@Testpublic 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();}}??
?