- 事务具有ACID原则，各个数据库实现了这些原则(用日志实现原子性，一致性，持久性，用锁实现隔离性)
- 隔离级别有四种(Read UnCommitted,Read Committed,Repeated Read, Serializable)，在不同的隔离级别下，有可能会出现脏读，不可重复读，幻读等现象
| 隔离级别 | 是否存在脏读 | 是否存在不可重复读 | 是否存在幻读 |
|---|---|---|---|
| Read UnCommitted | Y | Y | Y |
| Read Committed | N | Y | Y |
| Repeated Read | N | N | Y |
| Serializable | N | N | N |
脏读举例：
- Mary的原工资为1000, 财务人员将Mary的工资改为了8000(但未提交事务)
- Mary读取自己的工资 ,发现自己的工资变为了8000，欢天喜地！
- 而财务发现操作有误，回滚了事务,Mary的工资又变为了1000像这样,Mary记取的工资数8000是一个脏数据。
不可重复读：
- 在事务1中，Mary 读取了自己的工资为1000,操作并没有完成
- 在事务2中，这时财务人员修改了Mary的工资为2000,并提交了事务.
- 在事务1中，Mary 再次读取自己的工资时，工资变为了2000
幻读
目前工资为1000的员工有10人。
- 事务1,读取所有工资为1000的员工。
- 这时事务2向employee表插入了一条员工记录，工资也为1000
- 事务1再次读取所有工资为1000的员工 共读取到了11条记录，
本文就是用hibernate，然后修改mysql数据库中的隔离级别来重现上述现象，以此来深刻体会事务的隔离性
实体类：
package entity;
import java.util.Date;
public class User {
private int id;
private String userName;
private Date addtime;
public Date getAddtime() {
return addtime;
}
public void setAddtime(Date addtime) {
this.addtime = addtime;
}
public User(){}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
}
映射文件：
<?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="entity.User" table="_user" >
<id name="id">
<generator class="native" />
</id>
<property name="userName" />
<property name="addtime" type="time" />
</class>
</hibernate-mapping>
单元测试：
package entity;
import java.util.Date;
import java.util.List;
import org.hibernate.classic.Session;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.Projections;
import junit.framework.TestCase;
import util.hibernateUtil;
/**
* 测试目的： 1. 不同的数据库实现锁(隔离)的机制不同，在不同机制下，重现脏读，不可重复读，幻读等现象 2. 利用phpunit实现多事务争抢同一数据现象
* 3. 修改mysql数据库隔离级别
*
* @author arkulo
*
*/
public class TestTransaction extends TestCase {
// 1. 改变数据库隔离级别，至Read UnCommitted
// 查询mysql数据库的隔离级别：select @@global.tx_isolation,@@tx_isolation;
// 修改mysql数据库当前会话隔离级别：set session transaction isolation level read
// uncommitted;
//
// 问题：在数据库中修改的时候，该session会话级别的隔离是不行的，只能改global级别的隔离
// 这个函数是查询当前数据库的隔离级别
// 给user表中初始化一条数据
public void getACID() {
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
List res = session.createSQLQuery("select @@tx_isolation").list();
for (Object i : res) {
System.out.println("隔离级别：" + i.toString());
}
User user = new User();
user.setUserName("王蕊");
user.setAddtime(new Date());
// id策略是native，在save之后就立刻发出sql语句，这里设断点停住，不提交commit
session.save(user);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// 重现脏读：在一个事务未提交的时候，另外一个事务就可以读取到该事务中的新增数据
// 2. 启动第一个进程做断点，到save后停止，启动另外一个进程，直接执行，看看能不能读到数据库中的数据
public void test1() {
// getACID();
System.out.println("-------------------------------------");
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
User user = (User) session.load(User.class, 1);
System.out.println("用户名：" + user.getUserName());
user.setUserName("李四");
session.update(user);
session.flush();
// 单步断点，停在这里不提交，但是需要flush
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// 再启动一个进程，运行这个函数去读取user表中的第一条数据，这时候就会发现
// 1. 隔离级别是READ UNCOMMITED，读取事务并没有被阻塞
// 2. 这里读出的用户名是李四，属于脏读
public void test1_1() {
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
User user = (User) session.get(User.class, 1);
System.out.println("用户名：" + user.getUserName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
// 这里展示不可重复读问题
public void test2() {
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
User user = (User) session.get(User.class, 1);
System.out.println("用户名：" + user.getUserName());
// 因为get函数会缓存对象到一级缓存，这里需要把缓存清理掉
// 如果不清理，系统会采用缓存中的数据，而下面的get函数就不会发出sql语句查询
session.evict(user);
// 在这里断点停住，当另外一个用户的事务结束之后，这里再继续
User user1 = (User) session.get(User.class, 1);
// 这里读出的用户名是李四！！
System.out.println("用户名：" + user1.getUserName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// 当test2第一个查询执行完毕之后,test2_1修改用户名，然后再执行test2中的第二个查询
public void test2_1() {
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
User user = (User) session.get(User.class, 1);
user.setUserName("李四");
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
// 以下部分是幻读的重现
public void test3() {
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
// 以下是两种查询总数的方式，都会用到uniqueResult()
// int acount = ((Long)session.createQuery("select count(*) from
// User").uniqueResult()).intValue();
int acount = ((Number) session.createCriteria("entity.User").setProjection(Projections.rowCount())
.uniqueResult()).intValue();
System.out.println("数量：" + acount);
// 因为查询的不是对象，因此不会被一级缓存，这里断点停住
// 这里打印的数据库记录比上面多了1条，好像是幻觉一样
int acount1 = ((Number) session.createCriteria("entity.User").setProjection(Projections.rowCount())
.uniqueResult()).intValue();
System.out.println("数量：" + acount1);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
// 新起一个事务做插入
public void test3_1() {
Session session = null;
try {
session = hibernateUtil.getSession();
session.beginTransaction();
User user = new User();
user.setUserName("李四");
user.setAddtime(new Date());
session.save(user);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
hibernateUtil.closeSession(session);
}
}
}