MySQL具体解释（13）------------事务

一、 什么是事务

事务就是一段sql 语句的批处理。可是这个批处理是一个atom（原子） 。不可切割，要么都运行，要么回滚（rollback）都不运行。

二、为什么出现这样的技术

为什么要使用事务这个技术呢？ 如今的非常多软件都是多用户，多程序，多线程的，对同一个表可能同一时候有非常多人在用。为保持数据的一致性。所以提出了事务的概念。这样非常抽象。举个样例：

A 给B 要划钱。A 的账户-1000元， B 的账户就要+1000元。这两个update 语句必须作为一个总体来运行。不然A 扣钱了。B 没有加钱这样的情况非常难处理（找出原因）。

三、怎样在MYSQL 中使用事务

1、谁能够使用

仅仅有InnoDB /BDB　的之类的transaction_safe table 才干支持。

默认的engine MyISAM 是不支持事务的，show engine 能够看到支持的和默认的engine。能够在[mysqld] 增加： default_storage_engine=InnoDB;  InnoDB 就是建立表的默认引擎。

建立InnoDB 表：Create table .... type=InnoDB。 Alter table table_name type=InnoDB;（怎样查看已有表的类型： show create table table_name)

这样我们就能够在InnoDB 表上进行事务操作了。

2、怎样使用

启动事务的方法：

觉得分为两种：

1、begin ，rollback,commit .当然有的人用begin /begin work .推荐用START TRANSACTION 是SQL-99标准启动一个事务。

start transaction。

update from account set money=money-100 where name='a';

update from account set money=money+100 where name='b';

commit。

解释： 这样start transaction 手动开启事务，commit 手动关闭事务。

2、默认的时候autocommit=1 自己主动提交是开启的。所以你能够理解为每条语句一输入到mysql就commit 了。当你 set autocommit=0 时候，你能够这样：

update from account set money=money-100 where name='a';

update from account set money=money+100 where name='b';

commit；

// 默认都不提交，仅仅有手动键入commit 时候才上述都提交。

综述：一般使用１　方法。

四、举例

mysql> select * from employee;

+------------+------------+------------+--------------+

| employeeID | name       | job        | departmentID |

+------------+------------+------------+--------------+

|       6651 | Ajay Patel | Programmer |          128 |

|       7513 | Nora Edwar | Programmer |          128 |

|       9006 | Candy Burn | Systems Ad |          128 |

|       9842 | Ben Smith  | DBA        |           42 |

|       9843 | Pert Park  | DBA        |           42 |

|       9845 | Ben Patel  | DBA        |          128 |

|       9846 | Red Right  | x          |          128 |

|       9847 | Run Wild   | x          |          128 |

|       9848 | Rip This J | x          |          128 |

|       9849 | Rip This J | x          |          128 |

|       9850 | Reader U   | x          |          128 |

set auotcommit =0;

insert into employee values(null,"test1",null,128);

savepoint s1;

insert into employee values(null,"test2",null,128);

savepoint s2;

insert into employee values(null,"test3",null,128);

savepoint s3;

运行完三个插入语句。select * from employee 能够看到三条。

假设你想回滚到最初rollback 就是最初什么都没有做的状态。

假设你想回到savepoint s1 的状态（也就是插入一条test1 的那里） rollback to savpoint s1 .  同理什么都能够做了。

附录： 事务的ACID(Atomicity \Consistency \Isolation \Durablility)

A: 事务必须是原子（不可切割），要么运行成功进入下一个状态，要么失败rollback 到最初状态。

C：在事务開始之前和事务结束以后，数据库的完整性约束没有被破坏。 这个一般通过外键来约束。

I：一个事务不能知道另外一个事务的运行情况（中间状态）

D：在事务完毕以后，该事务所对数据库所作的更改便持久的保存在数据库之中。并不会被回滚。

mysql 自己的MyISAM 没有通过acid 測试，可是InnoDB 能够做到。

在分布式的系统中，一般会有多个线程连接到数据库中同一时候对一个表进行操作(这里的同一时候并不表示同一个时间点，而是同一时候竞争cpu的资源，至于怎样调度，就要看线程和操作系统怎样进行调度了)，这样的情况下如果会话的事物设置不当，就会导致数据混乱，经常会出现下面三种情况(如果如今系统中有两个会话A和B。同一时候对表T_Test操作)：

1.脏读：假设有A向B 做了这个操作：update account set money=money+100 where name='B'。在没有commit 之前B 查询：select money from account where name='B'；找到了没有提交的money 。之后A在此时有rollback ，B 再查询，100 不见了。为了避免提高级别：read committed 。就是仅仅能读取提交后的东东。

2.不可反复读：1中说明的就是我们不能读取一个事务的中间状态。 而反复读是指我们每次读取到的结果都要一直。 这个也是mysql 默认的级别。

mysql>  select @@tx_isolation ;

+-----------------+

| @@tx_isolation  |

+-----------------+

| REPEATABLE-READ |

+-----------------+

3.幻读：在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。和不可反复读的差别是：不可反复读是读取到了别人对表中的某一条记录进行了改动，导致前后读取的数据不一致。

虚读是前后读取到表中的记录总数不一样，读取到了其他事务插入的数据。比方如今有 A 和 B 两个应用程序，他们并发訪问了数据库中的某一张表，如果表中有 3 条记录，B 运行查询操作。 第一次查询表得到了 3 条记录。此时 A 对表进行了改动。添加了一条记录，当 B 再次查询表的时候，发现多了一条数据。这样的情况就造成了 B 的虚读。可是虚读是不一定每次都发生的。这样的情况是不确定的。为了避免虚读，我们能够将事物隔离级别设置为 serializable 如果设置成了这样的级别，那么数据库就变成了单线程訪问的数据库，导致性能减少非常多。

summary：

（1）Serializable：可避免脏读、不可反复读、虚读情况的发生。

（2）Repeatable read：可避免脏读、不可反复读情况的发生。

（可反复读。是 mysql 默认的事务隔离级别）

（3）Read committed：可避免脏读情况发生。（读取已提交的数据）

（4）Read uncommitted：最低级别，以上情况均无法保证。

（读取到了未提交的数据）

当我们将数据库的隔离级别设置为：Serializable 的时候。尽管能够避免全部并发訪问的问题。可是 Serializable 採用的是单线程来解决并发訪问的问题，也就是说在某一段时间内。仅仅能有一个用户对数据库进行操作，导致其他用户堵塞。导致数据库的訪问性能非常差。

1.读未提交（Read Uncommitted）：这样的隔离级别能够让当前事务读取到其他事物还没有提交的数据。这样的读取应该是在回滚段中完毕的。通过上面的分析，这样的隔离级别是最低的。会导致引发脏读。不可反复读。和幻读。

2.读已提交（Read Committed）：这样的隔离级别能够让当前事务读取到其他事物已经提交的数据。通过上面的分析。这样的隔离级别会导致引发不可反复读。和幻读。

3.可反复读取（Repeatable Read）：这样的隔离级别能够保证在一个事物中多次读取特定记录的时候都是一样的。通过上面的分析，这样的隔离级别会导致引发幻读。

4.串行（Serializable）：这样的隔离级别将事物放在一个队列中，每一个事物開始之后。别的事物被挂起。同一个时间点仅仅能有一个事物能操作数据库对象。

这样的隔离级别对于数据的完整性是最高的。可是同一时候大大减少了系统的可并发性。

五、非InnoDB怎么办？

妈的，肯定有人会说那我mysql 的默认MyISAM 怎么办？ 没有事务这种事情怎么处理呢？ 这个要用到第二种技术叫做LOCK ! 实际上实现上边那4 个安全级别的所用的技术就是LOCK ！

我怎么在处理锁的问题上。常常听到：共享锁、排它锁、悲观锁、乐观锁、行级锁、表级锁。

共享锁： 就是在读取数据的时候，给数据加入一个共享锁。共享和共享直接是不冲突的，可是和排他锁是冲突的。

排他锁： 更新数据的时候。安装排他锁。禁止其它一切行为。

场景：老公去在 ATM 上取钱，老婆在柜台存钱，如果这个账户中有 1000 元。老公首先运行查询操作。查询到账户剩余金额为 1000 此时程序将 1000 拿到内存中，老公取了 200 元，程序就运行了更新操作将账户剩余金额改为 800，可是当老公的程序没有 commit 的时候，老婆查询账户。此时账户剩余金额还是 1000 元。老婆存入 200 元，程序运行了更新操作将账户剩余金额改为 1200，然后老公将更新语句提交，接着老婆也将更新语句提交。最后导致的结果就是该账户的剩余金额为 1200。这就是更新丢失的问题。引发更新丢失的根源就是查询上。由于两方都是依据从数据库查询到的数据再对数据库中的数据进行更新的。解决更新丢失有三个方案：(1) 将事务隔离级别设置为最高，採用死锁策略。

(2) 採用悲观锁，悲观锁不是数据库中真正的锁。是人们看待事务的态度。(3) 採用乐观锁，乐观锁也不是数据库中真正的锁。

假设我们採用的是第一个方案时，老公进行查询操作，数据库为表添加了共享锁，老婆进行查询操作时数据库也添加了一个共享锁。

可是当老公进行更新数据库操作时，由于老婆拿着共享锁，导致老公不能添加排它锁，老婆进行更新操作时，由于老公拿着共享锁，导致老婆也拿不到排它锁。这就发生了死锁现象。你等我，我等你。

在 mysql 中。处理死锁的方案是释放掉一方的锁。这样就保证了一方更新成功。可是这样的性能极低。由于数据库频繁在解决死锁问题。

悲观锁（更新多，查询少时用）

假设我们採用的是第二个方案时。即採用悲观锁。

就是我们在操作数据库时採用悲观的态度，觉得别人会在此时并发訪问数据库。我们在查询语句中 select * from account where name='aaa' for update; 等于加了排它锁。当老公查询剩余金额的时候。select money from account where name='aaa' for update; 添加了排它锁，老婆查询账户剩余金额的时候， select money from account where name='aaa' for update；也要求对数据库加排它锁，由于老公已经拿到了排它锁，导致老婆不能加锁。所以老婆仅仅有等待老公运行完成。释放掉锁以后才干继续操作。

乐观锁（更新少，查询多时用）

。查询条件的版本还是查询过来的版本。比方，老公运行查询操作的时候。select money,version from account where name='aaa'; 如果此时查询到的版本为 0。老公在进行更新操作的时候 update account set money=money+100,version=version+1 where name='aaa' and version=0; 未提交时老婆来查询，查询到的版本依旧是 0，老婆也运行更新操作 update account set money=money+100,version=version+1 where name='aaa' and version=0; 如今老公提交了事务，老婆再提交事务的时候发现版本为 0 的记录没有了，所以就避免了数据丢失的问题。

只是这样的情况也导致了多个用户更新操作时。仅仅有一个用户的更新被运行。

行级别的锁：

select * from employee where employeeID=9857 for update;  where 后边是索引列

不是索引列那么就为表级别的锁

MySQL的事务支持不是绑定在MySQLserver本身，而是与存储引擎相关1.MyISAM：不支持事务，用于仅仅读程序提高性能 2.InnoDB：支持ACID事务、行级锁、并发 3.Berkeley DB：支持事务

 

 一个事务是一个连续的一组数据库操作，就好像它是一个单一的工作单元进行。换言之。永远不会是完整的事务，除非该组内的每一个单独的操作是成功的。

假设在事务的不论什么操作失败，则整个事务将失败。

实际上，会俱乐部很多SQL查询到一个组中，将运行全部的人都一起作为事务的一部分。

事务的特性： 

事务有下面四个标准属性的缩写ACID，通常被称为：

原子性: 确保工作单元内的全部操作都成功完毕，否则事务将被中止在故障点，和曾经的操作将回滚到曾经的状态。

一致性: 确保数据库正确地改变状态后，成功提交的事务。

隔离性: 使事务操作彼此独立的和透明的。

持久性: 确保提交的事务的结果或效果的系统出现问题的情况下仍然存在。

在MySQL中，事务開始使用COMMIT或ROLLBACK语句開始工作和结束。開始和结束语句的SQL命令之间形成了大量的事务。

COMMIT & ROLLBACK: 

这两个keyword提交和回滚主要用于MySQL的事务。

当一个成功的事务完毕后，发出COMMIT命令应使全部參与表的更改才会生效。

假设发生问题时。应发出一个ROLLBACK命令返回的事务中引用的每个表到曾经的状态。

能够控制的事务行为称为AUTOCOMMIT设置会话变量。假设AUTOCOMMIT设置为1（默认值），然后每个SQL语句（在事务与否）被觉得是一个完整的事务，并承诺在默认情况下。当它完毕。

AUTOCOMMIT设置为0时，发出SET AUTOCOMMIT =0命令。在随后的一系列语句的作用就像一个事务。直到一个明白的COMMIT语句时，没有活动的提交。

能够通过使用mysql_query()函数在PHP中运行这些SQL命令。

通用事务样例 

这一系列事件是独立于所使用的编程语言。能够建立在不论什么使用的语言来创建应用程序的逻辑路径。

能够通过使用mysql_query()函数在PHP中运行这些SQL命令。

BEGIN WORK開始事务发出SQL命令

发出一个或多个SQL命令。如SELECT，INSERT。UPDATE或DELETE

检查是否有不论什么错误，一切都根据的须要。

假设有不论什么错误，那么问题ROLLBACK命令，否则发出COMMIT命令。

在MySQL中的事务安全表类型：

假设打算使用MySQL事务编程。那么就须要一种特殊的方式创建表。有非常多支持事务但最流行的是InnoDB表类型。

从源码编译MySQL时。InnoDB表支持须要特定的编译參数。假设MySQL版本号没有InnoDB支持，请互联网服务提供商建立一个版本号的MySQL支持InnoDB表类型，或者下载并安装Windows或Linux/UNIX的MySQL-Max二进制分发和使用的表类型在开发环境中。

假设MySQL安装支持InnoDB表，仅仅需加入一个的TYPE=InnoDB 定义表创建语句。比如，以下的代码创建InnoDB表tcount_tbl：

代码例如以下	复制代码
root@host# mysql -u root -p password; Enter password:******* mysql> use TUTORIALS; Database changed mysql> create table tcount_tbl     -> (     -> tutorial_author varchar(40) NOT NULL,     -> tutorial_count  INT     -> ) TYPE=InnoDB; Query OK, 0 rows affected (0.05 sec)

能够使用其它GEMINI或BDB表类型。但它取决于您的安装，假设它支持这两种类型。

因为项目设计里面，牵扯到了金钱的转移。于是就要用到MYSQL的事务处理，来保证一组处理结果的正确性。

用了事务，就不可避免的要牺牲一部分速度，来保证数据的正确性。

仅仅有InnoDB支持事务

事务 ACID Atomicity（原子性）、Consistency（稳定性）、Isolation（隔离性）、Durability（可靠性）

1、事务的原子性

一组事务，要么成功。要么撤回。

2、稳定性

有非法数据（外键约束之类），事务撤回。

3、隔离性

事务独立执行。

一个事务处理后的结果，影响了其它事务，那么其它事务会撤回。

事务的100%隔离，须要牺牲速度。

4、可靠性

软、硬件崩溃后。InnoDB数据表驱动会利用日志文件重构改动。

可靠性和快速度不可兼得， innodb_flush_log_at_trx_commit选项 决定什么时候吧事务保存到日志里。

开启事务

START TRANSACTION 或 BEGIN

提交事务（关闭事务）

COMMIT

放弃事务（关闭事务）

ROLLBACK

折返点

SAVEPOINT adqoo_1

ROLLBACK TO SAVEPOINT adqoo_1

发生在折返点 adqoo_1 之前的事务被提交，之后的被忽略

事务的终止

设置“自己主动提交”模式

SET AUTOCOMMIT = 0

每条SQL都是同一个事务的不同命令，之间由 COMMIT 或 ROLLBACK隔开

掉线后，没有 COMMIT 的事务都被放弃

事务锁定模式

系统默认： 不须要等待某事务结束，可直接查询到结果，但不能再进行改动、删除。

缺点：查询到的结果，可能是已经过期的。

长处：不须要等待某事务结束，可直接查询到结果。

须要用下面模式来设定锁定模式

1、SELECT …… LOCK IN SHARE MODE（共享锁）

查询到的数据。就是数据库在这一时刻的数据（其它已commit事务的结果，已经反应到这里了）

SELECT 必须等待，某个事务结束后才干运行

2、SELECT …… FOR UPDATE（排它锁）

比如 SELECT * FROM tablename WHERE id<200

那么id<200的数据。被查询到的数据，都将不能再进行改动、删除、SELECT …… LOCK IN SHARE MODE操作

一直到此事务结束

共享锁 和 排它锁 的差别：在于是否阻断其它客户发出的 SELECT …… LOCK IN SHARE MODE命令

3、INSERT / UPDATE / DELETE

全部关联数据都会被锁定，加上排它锁

4、防插入锁

比如 SELECT * FROM tablename WHERE id>200

那么id>200的记录无法被插入

5、死锁

自己主动识别死锁

先进来的进程被运行，后来的进程收到出错消息，并按ROLLBACK方式回滚

innodb_lock_wait_timeout = n 来设置最长等待时间，默认是50秒

事务隔离模式

SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL

READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE

1、不带SESSION、GLOBAL的SET命令

仅仅对下一个事务有效

2、SET SESSION

为当前会话设置隔离模式

3、SET GLOBAL

为以后新建的全部MYSQL连接设置隔离模式（当前连接不包含在内）

隔离模式

READ UNCOMMITTED

不隔离SELECT

其它事务未完毕的改动（未COMMIT）。其结果也考虑在内

READ COMMITTED

把其它事务的 COMMIT 改动考虑在内

同一个事务中。同一 SELECT 可能返回不同结果

REPEATABLE READ（默认）

不把其它事务的改动考虑在内，不管其它事务是否用COMMIT命令提交过

同一个事务中。同一 SELECT 返回同一结果（前提是本事务。不改动）

SERIALIZABLE

和REPEATABLE READ类似，给全部的SELECT都加上了 共享锁

出错处理

依据出错信息，运行对应的处理

mysql事物处理实例

MYSQL的事务处理主要有两种方法

1.用begin,rollback,commit来实现

    begin開始一个事务

    rollback事务回滚

    commit 事务确认

2.直接用set来改变mysql的自己主动提交模式

    mysql默认是自己主动提交的，也就是你提交一个query，就直接运行！

能够通过

    set autocommit = 0 禁止自己主动提交

    set autocommit = 1 开启自己主动提交

    来实现事务的处理。

但要注意当用set autocommit = 0 的时候，你以后全部的sql都将作为事务处理，直到你用commit确认或 rollback结束，注意当你结束这个事务的同一时候也开启了新的事务！按第一种方法仅仅将当前的做为一个事务!

MYSQL仅仅有 INNODB和BDB类型的数据表才支持事务处理。其它的类型是不支持的!

MYSQL5.0 WINXP下測试通过～  ^_^

代码例如以下

复制代码

mysql> use test;     Database changed     mysql> CREATE TABLE `dbtest`(     -> id int(4)     -> ) TYPE=INNODB; Query OK, 0 rows affected, 1 warning (0.05 sec) mysql> select * from dbtest     -> ; Empty set (0.01 sec) mysql> begin; Query OK, 0 rows affected (0.00 sec) mysql> insert into dbtest values(5); Query OK, 1 row affected (0.00 sec) mysql> insert into dbtest value(6); Query OK, 1 row affected (0.00 sec) mysql> commit; Query OK, 0 rows affected (0.00 sec) mysql> select * from dbtest; +------+ | id   | +------+ |    5 | |    6 | +------+ 2 rows in set (0.00 sec) mysql> begin; Query OK, 0 rows affected (0.00 sec) mysql> insert into dbtest values(7); Query OK, 1 row affected (0.00 sec) mysql> rollback; Query OK, 0 rows affected (0.00 sec) mysql> select * from dbtest; +------+ | id   | +------+ |    5 | |    6 | +------+ 2 rows in set (0.00 sec)

mysql> mysql事务处理

php代码实现事务的处理能够通过PHP提前定义类mysqli的下面方法实现。

autocommit(boolean)：该方法用于限定查询结果是否自己主动提交，假设该方法的參数为true则自己主动提交。假设參数为false则关闭自己主动提交。

MySQL数据库默觉得自己主动提交。

rollback()：利用mysqli类中的该方法能够实现事务的回滚。

commit()：利用该方法能够实现提交全部查询。

代码例如以下	复制代码
<?php include_once("conn.php"); $id=$_GET[id]; $conn->autocommit(false); if(!$conn->query("delete from tb_sco where id='".$id."'")) {   $conn->rollback(); } if(!$conn->query("delete from tb_stu where id='".$id."'")) {   $conn->rollback(); }   $conn->commit();   $conn->autocommit(true);   echo "ok" ? >

列二

代码例如以下

复制代码

<? php require('connectDB.php'); //建立数据库连接 mssql_query("BEGIN TRANSACTION DEPS02_DEL"); //開始事务 $delete_dep_sql="DELETE FROM TBLDEPARTMENT WHERE DEPTID='{$_GET[deptid]}'"; // echo $delete_dep_sql."<br>"; mssql_query($delete_dep_sql); //操作数据库 // var_dump($del_result); $delete_result = mssql_query("select @@ROWCOUNT as id"); $delete_info = mssql_fetch_array($delete_result); $delete_rows = $delete_info[0]; // var_dump($delete_rows); mssql_free_result($delete_result); echo "<script language=javascript>"; if(true){    //推断是否回滚提交 mssql_query("COMMIT TRANSACTION DEPS02_DEL"); //提交事务 echo "alert('delete success!');"; }else{ mssql_query("ROLLBACK TRANSACTION DEPS02_DEL"); //回滚事务 echo "alert('delete faile!');"; } echo "</script>";mssql_close(); ? >

例3

MySQL的事务处理在处理实际问题中有着广泛且重要的应用，最常见的应用如银行转账业务、电子商务支付业务等等。可是，值得注意的是，MySQL的事务处理功能在MYSIAM存储引擎中是不支持的，在InnoDB存储引擎中是支持的。

如今上传一段代码。作为引导认识MySQL事务处理的開始，简单的实例，但融汇思想，相信会有非常大的帮助。

代码例如以下

复制代码

<?php $conn=mysql_connect('localhost','root','yourpassword')or die(mysql_error()); mysql_select_db('transaction',$conn); mysql_query('set names utf8'); //创建事务 mysql_query('START TRANSACTION') or die(mysql_error()); $sqlA="update A set account=account-1"; if(!mysql_query($sqlA)){ &nbsp;&nbsp;&nbsp; mysql_query('ROLLBACK') or exit(mysql_error());//推断当运行失败时回滚 &nbsp;   exit(); } $sqlB="update B set account=account+1"; if(!mysql_query($sqlB)){ &nbsp;&nbsp;&nbsp; mysql_query('ROLLBACK') or exit(mysql_error());//推断当运行失败时回滚 &nbsp;   exit(); } mysql_query('COMMIT')or die(mysql_error());//运行事务 mysql_close($conn); ? >

以上代码能够作为模拟银行转账业务的事务流程。以表A、B分别表示两个已在银行开户的账户，当账户A运行转出1元给账户B的操作时，假设操作运行失败，转出将会回滚至原始状态，不继续向下运行动作。反之。假设操作运行成功，则账户B可用剩余金额将添加1元。否则事务回滚至原始状态。