一、事务并发问题

数据库没有做任何并发处理的情况下有5类事务并发问题

A：第一类丢失更新：两个事务更新相同数据，如果一个事务提交，另一个事务回滚，第一个事务的更新会被回滚

B：脏读：第二个事务查询到第一个事务未提交的更新数据，第二个事务根据该数据执行，但第一个事务回滚，第二个事务操作脏数据

C：虚读：一个事务查询到了另一个事务已经提交的新数据，导致多次查询数据不一致

D：不可重复读：一个事务查询到另一个事务已经修改的数据，导致多次查询数据不一致

E：第二类丢失更新：多个事务同时读取相同数据，并完成各自的事务提交，导致最后一个事务提交会覆盖前面所有事务对数据的改变

事务并发问题.png

二、事务隔离

一般情况，数据库都会处理一些事务并发的问题，数据库提供了不同的事务隔离级别来处理不同的事务并发问题，事务隔离级别定义如下：

1. READ_UNCOMMITED：允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读（相当于没有做任何事务隔离）

2. READ_COMMITTED：允许在并发事务已经提交后读取。可防止脏读，但幻读和不可重复读仍可发生（ORACLE默认级别）

3. REPEATABLE_READ：对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。（MYSQL默认级别）

4. SERIALIZABLE：完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。（ORACLE支持）

数据库的隔离级别除了SERIALIZABLE，都不能处理第一类丢失更新和第二类丢失更新；
所以，数据库提供了锁机制来防止第一类丢失更新和第二类丢失更新；

事务隔离级别.png

三、Hibernate锁机制

1、悲观锁

在MYSQL中 ,为了避免第二类丢失更新出现,提供了悲观锁的机制;

1.1: SELECT FOR UPDATE就是在数据上添加一个共享锁的东西;

• 1,共享锁允许其他普通的SELECT语句执行;
• 2,共享锁排斥其他的SELECT FOR UPDATE;
• 3,共享锁排斥INSERT DELETE等DML;

1.2: Hibernate使用悲观锁其实就是使用数据库锁：

如果数据库不支持设置的锁机制，hibernate会使用该数据库提供的合适的锁机制来完成，而不会报错。

• 1，使用session.load(class,id,LockOptions);加悲观锁，相当于发送SELECT ... FOR UPDATE
• 2，使用session.get(class,id,LockOptions);加悲观锁，相当于发送SELECT ... FOR UPDATE
• 3，使用session.buildLockRequest(LockOptions).lock(entity);加悲观锁，相当于发送SELECT id FROM ... FOR UPDATE
• 4，使用query.setLockOptions(LockOptions)；加悲观锁，相当于发送SELECT... FOR UPDATE

1,session1.createQuery("").setLockOptions(LockOptions.UPGRADE);
2,Account a=(Account)session1.get(Account.class,1L,LockOptions.UPGRADE);
3,Account a=(Account)session1.load(Account.class,1L,LockOptions.UPGRADE);

注意：
使用悲观锁会在一定情况下降低系统的并发性能;
如果系统对数据安全的要求非常高,请使用悲观锁;

例： 账号余额10000时，进行存取操作

@Test
    public void test1() {
        Session session1 = HibernateUtil.getHibernateSession();
        Session session2 = HibernateUtil.getHibernateSession();
        session1.beginTransaction();
        session2.beginTransaction();

        Account a1 = session1.get(Account.class, 1L);
        Account a2 = session2.get(Account.class, 1L);

        a1.setBalance(a1.getBalance() - 5000);
        a2.setBalance(a2.getBalance() + 5000);

        session1.getTransaction().commit();
        session2.getTransaction().commit();

    }

操作后，余额15000，发生第二类丢失更新

2、乐观锁

使用一个额外的版本控制字段来防止第二类丢失更新；
1，给表添加一个额外的数字类型字段version；
2，在insert一个对象的时候初始化version值为0；
3，在select的时候，查询出对象的版本号；
4，在update的时候，
1，更新版本号，version = version+1；
2，在update的where条件中带上当前更新对象的版本号 where .. and version = ?
3，如果update返回影响条数>0，说明更新成功；
4，如果update返回影响条数=0，说明更新的对象已经被其他事务更新或者删除，抛出异常，回滚当前事务；

---

在hibernate中使用乐观锁，推荐使用version方式；
1，给对象添加一个int version字段，最好设置属性为private；
2，在mapping文件中添加<version>元素即可；

<?xml version="1.0"?>
        <!DOCTYPE hibernate-mapping PUBLIC
                "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
                "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.revanwang.account">

    <class name="Account">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <version name="version"/>
        <property name="balance"/>
    </class>

</hibernate-mapping>