mysql命令行什么时候需要手动开启事务？

MySQL的事务如果不在任何修改，默认是自动提交的，也就是你只要执行一个SQL，回车之后这个SQL语句如果没有任何问题，只需完成后是自动提交的。

控制这个功能的参数是：autocommit。如果这个参数的值是on或者1，那么就是上面我说的那种现象。如果是off或者0，则表示不会自动提交事务。需要你显示的去提交事务。否则锁执行的SQL不会不会永久生效，只会对你当前命令行的session有效，退出MySQL后，执行的SQL语句将会别回滚。

当你需要两个SQL语句同时成功或者同时失败的时候，你可以手动地开启一个事务。比如下面的场景：

你想向订单表order_info表中插入一条新的订单记录，同时要想支付信息表payment_info中插入一条支付信息记录，这个时候从业务的角度上来看，这两个表中的插入 *** 作，需要保持原子性(也就是事务的四大特性之一)，也就是要么都插入成功，要么都插入失败，不能存在订单插入成功，支付插入失败，反之也不可以。

要满足上面的需求，你就需要手动的去开启一个事务，在这个事务中去插入两个表中的数据。然后再提交这个事务。如果这两个表的插入 *** 作，你不手动的开启事务，MySQL自己会把两个SQL语句分开放在两个单独的事务中。执行一个插入，就会自动提交一个事务，然后在执行另外一个插入，再自动提交另外一个事务。

在MySQL看来，这是两个分别向两个表中插入的SQL语句而已，它不会从业务上考虑这两个SQL实际的业务逻辑背景是什么。所以此时他会看成是两个SQL语句，也就是两个事务。

这样的情况下就需要手动的开启事务。

当多个用户访问同一份数据时，一个用户在更改数据的过程中，可能有其他用户同时发起更改请求，为保证数据库记录的更新从一个一致性状态变为另外一个一致性状态，使用事务处理是非常必要的，事务具有以下四个特性：

MySQL 提供了多种事务型存储引擎，如 InnoDB 和 BDB 等，而 MyISAM 不支持事务。为了支持事务，InnoDB 存储引擎引入了与事务处理相关的 REDO 日志和 UNDO 日志，同时事务依赖于 MySQL 提供的锁机制

事务执行时需要将执行的事务日志写入日志文件，对应的文件为 REDO 日志。当每条 SQL 进行数据更新 *** 作时，首先将 REDO 日志写进日志缓冲区。当客户端执行 COMMIT 命令提交时，日志缓冲区的内容将被刷新到磁盘，日志缓冲区的刷新方式或者时间间隔可以通过参数 innodb_flush_log_at_trx_commit 控制

REDO 日志对应磁盘上的 ib_logifleN 文件，该文件默认为 5MB，建议设置为 512MB，以便容纳较大的事务。MySQL 崩溃恢复时会重新执行 REDO 日志的记录，恢复最新数据，保证已提交事务的持久性

与 REDO 日志相反，UNDO 日志主要用于事务异常时的数据回滚，具体内容就是记录数据被修改前的信息到 UNDO 缓冲区，然后在合适的时间将内容刷新到磁盘

假如由于系统错误或者 rollback *** 作而导致事务回滚，可以根据 undo 日志回滚到没修改前的状态，保证未提交事务的原子性

与 REDO 日志不同的是，磁盘上不存在单独的 UNDO 日志文件，所有的 UNDO 日志均存在表空间对应的 .ibd 数据文件中，即使 MySQL 服务启动了独立表空间

在 MySQL 中，可以使用 BEGIN 开始事务，使用 COMMIT 结束事务，中间可以使用 ROLLBACK 回滚事务。MySQL 通过 SET AUTOCOMMIT、START TRANSACTION、COMMIT 和 ROLLBACK 等语句支持本地事务

MySQL 定义了四种隔离级别，指定事务中哪些数据改变其他事务可见、哪些数据该表其他事务不可见。低级别的隔离级别可以支持更高的并发处理，同时占用的系统资源更少

InnoDB 系统级事务隔离级别可以使用以下语句设置：

查看系统级事务隔离级别：

InnoDB 会话级事务隔离级别可以使用以下语句设置：

查看会话级事务隔离级别：

在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。读取未提交的数据称为脏读（Dirty Read），即是：首先开启 A 和 B 两个事务，在 B 事务更新但未提交之前，A 事务读取到了更新后的数据，但由于 B 事务回滚，导致 A 事务出现了脏读现象

所有事务只能看见已经提交事务所做的改变，此级别可以解决脏读，但也会导致不可重复读（Nonrepeatable Read）：首先开启 A 和 B 两个事务，A事务读取了 B 事务的数据，在 B 事务更新并提交后，A 事务又读取到了更新后的数据，此时就出现了同一 A 事务中的查询出现了不同的查询结果

MySQL 默认的事务隔离级别，能确保同一事务的多个实例在并发读取数据时看到同样的数据行，理论上会导致一个问题，幻读（Phontom Read）。例如，第一个事务对一个表中的数据做了修改，这种修改会涉及表中的全部数据行，同时第二个事务也修改这个表中的数据，这次的修改是向表中插入一行新数据，此时就会发生 *** 作第一个事务的用户发现表中还有没有修改的数据行

InnoDB 通过多版本并发控制机制（MVCC）解决了该问题：InnoDB 通过为每个数据行增加两个隐含值的方式来实现，这两个隐含值记录了行的创建时间、过期时间以及每一行存储时间发生时的系统版本号，每个查询根据事务的版本号来查询结果

通过强制事务排序，使其不可能相互冲突，从而解决幻读问题。简而言之，就是在每个读的数据行上加上共享锁实现，这个级别会导致大量的超时现象和锁竞争，一般不推荐使用

为了解决数据库并发控制问题，如走到同一时刻客户端对同一张表做更新或者查询 *** 作，需要对并发 *** 作进行控制，因此产生了锁

共享锁的粒度是行或者元组（多个行），一个事务获取了共享锁以后，可以对锁定范围内的数据执行读 *** 作

排他锁的粒度与共享锁相同，一个事务获取排他锁以后，可以对锁定范围内的数据执行写 *** 作

有两个事务 A 和 B，如果事务 A 获取了一个元组的共享锁，事务 B 还可以立即获取这个元组的共享锁，但不能获取这个元组的排他锁，必须等到事务 A 释放共享锁之后。如果事务 A 获取了一个元组的排他锁，事务 B 不能立即获取这个元组的共享锁，也不能立即获取这个元组的排他锁，必须等到 A 释放排他锁之后

意向锁是一种表锁，锁定的粒度是整张表，分为意向共享锁和意向排他锁。意向共享锁表示一个事务有意对数据上共享锁或者排他锁。有意表示事务想执行 *** 作但还没真正执行

锁的粒度主要分为表锁和行锁

表锁的开销最小，同时允许的并发量也是最小。MyISAM 存储引擎使用该锁机制。当要写入数据时，整个表记录被锁，此时其他读/写动作一律等待。一些特定的动作，如 ALTER TABLE 执行时使用的也是表锁

行锁可以支持最大的并发，InnoDB 存储引擎使用该锁机制。如果要支持并发读/写，建议采用 InnoDB 存储引擎

看你是什么事务，jdbc事务，还是分布式事务，还是容器事务

1，编程式事务管理（jdbc的事务是绑定在connection上的）

Connection conn = null

try

{

Class.forName("com.mysql.jdbc.Driver")

conn = DriverManager.getConnection("jdbc:oracle:thin:@host:1521:SID","username","password")

conn.setAutoCommit(false) //取消自动提交

PreparedStatement ps = conn.prepareCall("update something")

ResultSet rs = ps.executeQuery()

conn.commit() //手动提交

}

catch (Exception e)

{

conn.rollback()

e.printStackTrace()

}

finally

{

conn.close()

}

2，声明式事务

先在工程的application.xml配置文件中添加如下代码，开启事务

<!-- 声明式事务控制配置 -->

<tx:annotation-driven transaction-manager="txManager"/>

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="datasource" ref="bassDataSource"></property>

</bean>

然后在你需要开启事务的接口前面添加注解

@Transactional(rollbackFor = IOException.class)

public void add(String name) throws IOException

{

System.out.println("可以再类里和方法里面添加事务注解0~0")

throw new IOException()

}

直接调用接口方法就好

分布式事务处理（mysql貌似在5.X之后才支持） 的话，

1.可以直接使用spring+atomikos框架进行管理

参考：http://blog.chinaunix.net/uid-21162795-id-3424973.html

就不贴测试代码了，自己看着配置吧

2，使用JTA（Java Transaction API）进行分布式事务管理（测试代码如下）

import java.sql.Connection

import java.sql.PreparedStatement

import java.sql.SQLException

import javax.naming.InitialContext

import javax.sql.DataSource

import javax.transaction.SystemException

import javax.transaction.UserTransaction

import com.mysql.jdbc.jdbc2.optional.MysqlDataSource

//分布式事务处理

public class transferAccount

{

@SuppressWarnings("null")

public void testTransferAccount()

{

UserTransaction userts = null

Connection connA = null

PreparedStatement psA = null

InitialContext context = null

Connection connB = null

PreparedStatement psB = null

try

{

//获得事务管理对象

userts = (UserTransaction) context.lookup("java:comp/UserTransaction")

//获取两个数据库

connA = getDataSourceA().getConnection()

connB = getDataSourceB().getConnection()

//开启事务

userts.begin()

//sql语句

psA = connA.prepareStatement("我加1")

psB = connB.prepareStatement("我减1")

//执行sql

psA.executeUpdate()

psB.executeUpdate()

//事务提交

userts.commit()

} catch (Exception e)

{

try

{

userts.rollback()

} catch (IllegalStateException | SecurityException

| SystemException e1)

{

e1.printStackTrace()

}

e.printStackTrace()

}

finally

{

try

{

psA.close()

psB.close()

connA.close()

connB.close()

} catch (SQLException e)

{

e.printStackTrace()

}

}

}

public DataSource getDataSourceA()

{

MysqlDataSource dataSource = new MysqlDataSource()

dataSource.setDatabaseName("mysql")

dataSource.setServerName("server")

dataSource.setPortNumber(1433)

dataSource.setUser("test")

dataSource.setPassword("test")

return dataSource

}

public DataSource getDataSourceB()

{

MysqlDataSource dataSource = new MysqlDataSource()

dataSource.setDatabaseName("mysql")

dataSource.setServerName("server")

dataSource.setPortNumber(1435)

dataSource.setUser("test1")

dataSource.setPassword("test1")

return dataSource

}

}

---