数据库--事务Transaction

            一、事务的概念：

                   事务（Transaction）是指逻辑上的一组操作，事务是用于保证数据的唯一性，它由一组相关的DML语句组成，该DML语句要么全部成功，要么全部失败。这些操作

          是一个不可分割的工作单位，是DB环境中的逻辑工作单位。事务是为了保证数据库的完整性，事务不能嵌套。

                  事务的管理：默认的情况下，数据库会自动的管理事务，管理的方式是一条语句就独占一个事务。如果要自己控制事务也可以通过如下的命令开启、提交、回滚事务

           开启事务：start transaction

           提交事务：commit

           回滚事务：rollback

                  JDBC中事务管理：

                        conn.setAutoCommit(false);

                        conn.commit();

                        conn.rollback();

                        SavePoint sp = conn.setSavePoint();

                        conn.rollback(sp);

            二、事务的四大特性：ACID

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

                  1.原子性（Automic）：事务是一个不可分割的工作单位，事务中的操作要么都不发生，要么都发生。

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

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

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

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

           三、数据库的事务隔离机制：

                 1.隔离性：事务的隔离性，在事务中，多个线程操作同一张表相同的记录时，每个线程要相互的隔离。那么数据库如何设计才能保证呢？如果将数据库设计成单线程

           的数据库，可以防止所有的线程安全问题，自然就保证了数据库的隔离性，但是如果数据库设计成单线程的，那么面对高并发的数据访问时，这种数据的效率就是非常

          低效的。

                  2.数据库中的锁机制：

                      第一种方式：

                        A.共享锁：----S锁：只读事务

                        B.互斥锁：----X锁：任何操作都不能做

                      第二种方式：

                        A.行级锁：锁住表的一行

                        B.表级锁：

                                    a.行级共享锁：可以执行查询

                                    b.行级互斥锁：要等锁释放才可以执行操作

                 3.共享锁和互斥锁：

                       A.共享锁：

                               在非Serializable隔离级别做查询不加任何锁，而在Serializable隔离级别下做的查询加上共享锁。

                           共享锁的特点：共享锁和共享锁可以共存，但是共享锁和互斥锁不能共存

                       B.互斥锁：

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

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

                  4.隔离机制

                              如果两个线程并发修改，一定会出现问题，这是必须要利用锁机制来防止多个线程并发的修改数据；如果是两个线程并发的查询数据，没有线程安全问题。上

                     面两种都是极端的情况，如果是两个线程中，一个修改，一个查询，那么就会出现不同的情况：

                                     a.脏读：一个事务读取到了另一事务未提交的数据

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

                                     c.幻读（虚读）：在一个事务内读取到了别的事务插入的数据，导致前后读取的数据不一致（表级别的问题）

                               针对上面的三种情况，都违背了数据库的隔离性，对于脏读和不可重复读，强调的是内容的改变，而对于虚读强调的是数量的变化。

                               由于事务的隔离性会出现不同的情况，所以数据库的设计者就提供了不同的隔离机制来供使用数据库的用户来对自己的特殊情况作出自己的选择，所以数据库

                      设计者提供了一下四种事务的隔离级别：

                                       a.Read uncommitted ==不防止任何隔离性问题，会出现脏读，不可重复读，虚读问题

                                       b.Read committed == 可以防止脏读问题，但是不能防止不可重复读和虚读问题

                                       c.Repeatable read == 可以防止脏读和不可重复读问题，但是不能避免虚读问题

                                       d.Serializable ==此种机制，相当于将数据库设计成单线程数据库，可以防止上面的任何隔离性问题

                               四种隔离机制的比较：

                                      从安全性考虑：Serializable > Repeatable read >Read committed > Read uncommitted

                                      从效率上考虑：Read uncommited > Read committed > Repeatable read > Serializable

                               对于要使用数据库的时候，要根据自己使用数据库的需求，综合分析对安全性和效率的要求，选择一个隔离级别使数据库运行在这个隔离级别上。

                               不同的数据库对默认的事务隔离级别是不同的：mysql 默认隔离级别是 Repeatable read隔离级别，而对于Oracle 默认的隔离级别是Read committed。

                   5.查询隔离机制：

                           a.查询当前数据库的隔离级别：

                                 Select @@tx_isolation;

                           b.设置隔离级别：

                                 Set [global/session] transaction isolation level xxx;

                               注意：其中如果不写设置的对象是globle或session则默认是session。session是指修改当前客户端和数据库交互时的隔离级别，而如果使用global,则修改的

                                           是数据库的默认隔离级别。

 

                        

              四、乐观锁和悲观锁

                      问题引出：两个线程基于同一个查询结果进行修改，后修改的人会将修改人的修改记录覆盖掉。

                     1. 乐观锁：乐观锁会乐观的认为每次查询都不会造成更新丢失，利用一个版本字段进行控制。

                      2.悲观锁：悲观锁悲观的认为每一次操作都会造成更新丢死问题，在每次查询时就加上互斥锁。

                      总结：

                               对于查询非常多，修改非常少，使用乐观锁

                              对于修改非常多，查询非常少，使用悲观锁