事务(Transaction)

1.事务的概念

　　事务是指逻辑上的 一组操作，这组操作 要么同时完成，要么同时不完成.

　　事务的管理：默认情况下，数据库会自动管理事务，管理的方式是 一条语句就独占一个事务.
　　

开启事务

　　　　 start transaction

提交事务

　　　　 commit

回滚事务

　　　　 rollback

JDBC中管理事务：

　　　　conn.setAutoCommit(false);
　　　　conn.commit();／conn.rollback();

设置事务的回滚点：

　　　　SavePoint sp = conn.setSavePoint();
　　　　conn.rollback(sp);
　　　　conn.commit(); //回滚后必须提交

2.事务的四大特性：

　　一个事务具有的最基本的特性，一个设计良好的数据库可以帮我们保证事务具有这四大特性(ACID)

原子性：

　　原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

一致性：

　　 如果事务执行之前数据库是一个完整性的状态，那么事务结束后，无论事务是否执行成功，数据库仍然是一个完整性状态.

数据库的完整性状态：当一个数据库中的所有的数据都符合数据库中所定义的所有的约束，此时可以称数据库是一个完整性状态.

隔离性：

　　事务的隔离性是指多个用户并发访问数据库时，一个用户的事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离。

持久性：

持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。

利用隔离性保证线程安全：

　　将数据库设计成单线程的数据库，可以防止所有的线程安全问题，自然就保证了隔离性.但是如果数据库设计成这样，那么效率就会极其低下.

3.数据库中的锁机制：

共享锁：

　　 在非Serializable隔离级别做查询不加任何锁，而在Serializable隔离级别下做的查询加共享锁
　　
特点：共享锁和共享锁可以共存，但是共享锁和排他锁不能共存

排他锁：

　　在所有隔离级别下进行增删改的操作都会加排他锁

特点：和任意其他锁都不能共存

3.1到底要不要加锁？

提出3个问题：
　　1.如果是两个线程并发修改，一定会互相捣乱，这时必须利用锁机制防止多个线程的并发修改
　　2.如果两个线程并发查询，没有线程安全问题
　　3.如果两个线程一个修改，一个查询……

四大隔离级别（解决以上3种问题）：

Read uncommitted	不防止任何隔离性问题，具有脏读/不可重复度/虚读(幻读)问题
Read committed	可以防止脏读问题，但是不能防止不可重复度/虚读(幻读)问题
Repeatable read	可以防止脏读/不可重复读问题，但是不能防止虚读(幻读)问题
Serializable	数据库被设计为单线程数据库，可以防止上述所有问题

性能对比：

从安全性上考虑： Serializable > Repeatable read > read committed > read uncommitted
从效率上考虑： read uncommitted > read committed > Repeatable read > Serializable

用户如何选择？

　　真正使用数据库的时候，根据自己使用数据库的需求，综合分析对安全性和对效率的要求，选择一个隔离级别，使数据库运行在这个隔离级别上.
　　
　　mysql 默认下就是Repeatable read隔离级别
　　oracle 默认下就是Read committed隔离级别

　　 查询当前数据库的隔离级别：select @@tx_isolation;
　　
　　设置隔离级别：
　　set [global/session] transaction isolation level xxxx;
　　其中如果不写默认是session，指的是修改当前客户端和数据库交互时的隔离级别，而如果使用golbal，则修改的是数据库的默认隔离级别

## 脏读举例：一个事务读取到另一个事务未提交的数据

    　a要打100元钱给b 刚开始两个人各有1000元
        a 1000
        b 1000

        ----------
      **a告诉b要打钱了，同时也开启了事务，打了100块过去，但是还没提交事务
        a：
            start transaction;
            update account set money=money-100 where name=a;
            update account set money=money+100 where name=b;
        ----------
     **b在取款机旁边一直在查，结果查到b账户真的多了100块钱    
        b：
            start transaction;
            select * from account;

                a ： 900
                b ： 1100
        ----------
      **但这时，a回滚了事务
        a：
            rollback;
        ----------
      **b刚要取钱时，查到自己又成原来的余额了，
        b：
            start transaction;
            select* from account;
                a： 1000
                b： 1000

       这就是脏读，即读到了还未提交事务的数据        

## 不可重复读：在一个事务内读取表中的某一行数据，多次读取结果不同 — 行级别的问题

**一位银行职员b要统计本行中a储户的资金总额（假设有3种储蓄方式，活期、定期、固定 各1000元储蓄）
        a： 1000  1000  1000
        b： 银行职员

        ---------
**b要开始统计数据了，开启了事务，写SQL中：
        b：start transaction;
        select 活期存款 from account where name='a'; ---- 活期存款：1000
        select 定期存款 from account where name='a'; ---- 定期存款：1000
        select 固定资产 from account where name='a'; ---- 固定资产：1000       
            -------
 **与此同时，储户a从活期账户中取走了1000元，开启并成功提交了取钱事务
            a：
                start transaction;
                update accounset set 活期=活期-1000 where name='a';
                commit;
            -------
  **当b再次统计查询时，发现账户总额中少了1000元。。。6666666
        select 活期+定期+固定 from account where name='a';  --- 总资产：2000
        commit;
        ----------

＃＃ 虚读(幻读)：是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致 — 表级别的问题

    储户a、b在银行分别存放1000元存款（只有a和b两个储户）
        a： 1000
        b： 1000
        d： 银行业务人员

        -----------
 **银行职员d要统计本行中人均存款
        d：
            start transaction;
            select sum(money) from account; --- 2000 元
            select count(name) from account; --- 2 个

            ------
   **这时，储户c向银行中存入了4000元
        c：
            start transaction;
            insert into account values(c，4000);
            commit;
            ------
   **当职员d再次统计平均存款的时候，发现结果成了：a和b各存款1000元，两人的平均存款2000元
        d:   
            select sum(money)/count(name) from account; --- 平均：2000元/人
            commit;
        ------------