`

MySQL的事务管理

MySQL应用服务器SQL 
阅读更多

1，MySQL的事务支持
MySQL的事务支持不是绑定在MySQL服务器本身，而是与存储引擎相关：

Java代码 复制代码
  1. MyISAM：不支持事务，用于只读程序提高性能   
  2. InnoDB：支持ACID事务、行级锁、并发   
  3. Berkeley DB：支持事务  
MyISAM：不支持事务，用于只读程序提高性能
InnoDB：支持ACID事务、行级锁、并发
Berkeley DB：支持事务



隔离级别：
隔离级别决定了一个session中的事务可能对另一个session的影响、并发session对数据库的操作、一个session中所见数据的一致性
ANSI标准定义了4个隔离级别，MySQL的InnoDB都支持：

Java代码 复制代码
  1. READ UNCOMMITTED：最低级别的隔离，通常又称为dirty read，它允许一个事务读取还没commit的数据，这样可能会提高性能，但是dirty read可能不是我们想要的   
  2. READ COMMITTED：在一个事务中只允许已经commit的记录可见，如果session中select还在查询中，另一session此时insert一条记录，则新添加的数据不可见   
  3. REPEATABLE READ：在一个事务开始后，其他session对数据库的修改在本事务中不可见，直到本事务commit或rollback。在一个事务中重复select的结果一样，除非本事务中update数据库。   
  4. SERIALIZABLE：最高级别的隔离，只允许事务串行执行。为了达到此目的，数据库会锁住每行已经读取的记录，其他session不能修改数据直到前一事务结束，事务commit或取消时才释放锁。  
READ UNCOMMITTED：最低级别的隔离，通常又称为dirty read，它允许一个事务读取还没commit的数据，这样可能会提高性能，但是dirty read可能不是我们想要的
READ COMMITTED：在一个事务中只允许已经commit的记录可见，如果session中select还在查询中，另一session此时insert一条记录，则新添加的数据不可见
REPEATABLE READ：在一个事务开始后，其他session对数据库的修改在本事务中不可见，直到本事务commit或rollback。在一个事务中重复select的结果一样，除非本事务中update数据库。
SERIALIZABLE：最高级别的隔离，只允许事务串行执行。为了达到此目的，数据库会锁住每行已经读取的记录，其他session不能修改数据直到前一事务结束，事务commit或取消时才释放锁。



可以使用如下语句设置MySQL的session隔离级别：

Java代码 复制代码
  1. SET TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE}  
SET TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE}



MySQL默认的隔离级别是REPEATABLE READ，在设置隔离级别为READ UNCOMMITTED或SERIALIZABLE时要小心，READ UNCOMMITTED会导致数据完整性的严重问题，而SERIALIZABLE会导致性能问题并增加死锁的机率

事务管理语句：

Java代码 复制代码
  1. START TRANSACTION：开始事务，autocommit设为0，如果已经有一个事务在运行，则会触发一个隐藏的COMMIT   
  2. COMMIT：提交事务，保存更改，释放锁   
  3. ROLLBACK：回滚本事务对数据库的所有更改，然后结束事务，释放锁   
  4. SAVEPOINT savepoint_name：创建一个savepoint识别符来ROLLBACK TO SAVEPOINT   
  5. ROLLBACK TO SAVEPOINT savepoint_name：回滚到从savepoint_name开始对数据库的所有更改，这样就允许回滚事务中的一部分，保证更改的一个子集被提交   
  6. SET TRANSACTION：允许设置事务的隔离级别   
  7. LOCK TABLES：允许显式的锁住一个或多个table，会隐式的关闭当前打开的事务，建议在执行LOCK TABLES语句之前显式的commit或rollback。我们一般所以一般在事务代码里不会使用LOCK TABLES  
START TRANSACTION：开始事务，autocommit设为0，如果已经有一个事务在运行，则会触发一个隐藏的COMMIT
COMMIT：提交事务，保存更改，释放锁
ROLLBACK：回滚本事务对数据库的所有更改，然后结束事务，释放锁
SAVEPOINT savepoint_name：创建一个savepoint识别符来ROLLBACK TO SAVEPOINT
ROLLBACK TO SAVEPOINT savepoint_name：回滚到从savepoint_name开始对数据库的所有更改，这样就允许回滚事务中的一部分，保证更改的一个子集被提交
SET TRANSACTION：允许设置事务的隔离级别
LOCK TABLES：允许显式的锁住一个或多个table，会隐式的关闭当前打开的事务，建议在执行LOCK TABLES语句之前显式的commit或rollback。我们一般所以一般在事务代码里不会使用LOCK TABLES



2，定义事务
MySQL默认的行为是在每条SQL语句执行后执行一个COMMIT语句，从而有效的将每条语句独立为一个事务。
在复杂的应用场景下这种方式就不能满足需求了。
为了打开事务，允许在COMMIT和ROLLBACK之前多条语句被执行，我们需要做以下两步：
1, 设置MySQL的autocommit属性为0，默认为1
2，使用START TRANSACTION语句显式的打开一个事务

如果已经打开一个事务，则SET autocommit=0不会起作用，因为START TRANSACTION会隐式的提交session中所有当前的更改，结束已有的事务，并打开一个新的事务。

使用SET AUTOCOMMIT语句的存储过程例子：

Java代码 复制代码
  1. CREATE PROCEDURE tfer_funds   
  2.     (from_account int, to_account int, tfer_amount numeric(10,2))   
  3. BEGIN   
  4.     SET autocommit=0;   
  5.   
  6.     UPDATE account_balance SET balance=balance-tfer_amount WHERE account_id=from_account;   
  7.   
  8.     UPDATE account_balance SET balance=balance+tfer_amount WHERE account_id=to_account;   
  9.   
  10.     COMMIT;   
  11. END;  
CREATE PROCEDURE tfer_funds
    (from_account int, to_account int, tfer_amount numeric(10,2))
BEGIN
    SET autocommit=0;

    UPDATE account_balance SET balance=balance-tfer_amount WHERE account_id=from_account;

    UPDATE account_balance SET balance=balance+tfer_amount WHERE account_id=to_account;

    COMMIT;
END;


使用START TRANSACITON打开事务的例子：

Java代码 复制代码
  1. CREATE PROCEDURE tfer_funds   
  2.     (from_account int, to_account int, tfer_amount numeric(10,2))   
  3. BEGIN   
  4.     START TRANSACTION;   
  5.   
  6.     UPDATE account_balance SET balance=balance-tfer_amount WHERE account_id=from_account;   
  7.   
  8.     UPDATE account_balance SET balance=balance+tfer_amount WHERE account_id=to_account;   
  9.   
  10.     COMMIT;   
  11. END;  
CREATE PROCEDURE tfer_funds
    (from_account int, to_account int, tfer_amount numeric(10,2))
BEGIN
    START TRANSACTION;

    UPDATE account_balance SET balance=balance-tfer_amount WHERE account_id=from_account;

    UPDATE account_balance SET balance=balance+tfer_amount WHERE account_id=to_account;

    COMMIT;
END;



通常COMMIT或ROLLBACK语句执行时才完成一个事务，但是有些DDL语句等会隐式触发COMMIT，所以应该在事务中尽可能少用或注意一下：

Java代码 复制代码
  1. ALTER FUNCTION   
  2. ALTER PROCEDURE   
  3. ALTER TABLE   
  4. BEGIN   
  5. CREATE DATABASE   
  6. CREATE FUNCTION   
  7. CREATE INDEX   
  8. CREATE PROCEDURE   
  9. CREATE TABLE   
  10. DROP DATABASE   
  11. DROP FUNCTION   
  12. DROP INDEX   
  13. DROP PROCEDURE   
  14. DROP TABLE   
  15. UNLOCK TABLES   
  16. LOAD MASTER DATA   
  17. LOCK TABLES   
  18. RENAME TABLE   
  19. TRUNCATE TABLE   
  20. SET AUTOCOMMIT=1  
  21. START TRANSACTION  
ALTER FUNCTION
ALTER PROCEDURE
ALTER TABLE
BEGIN
CREATE DATABASE
CREATE FUNCTION
CREATE INDEX
CREATE PROCEDURE
CREATE TABLE
DROP DATABASE
DROP FUNCTION
DROP INDEX
DROP PROCEDURE
DROP TABLE
UNLOCK TABLES
LOAD MASTER DATA
LOCK TABLES
RENAME TABLE
TRUNCATE TABLE
SET AUTOCOMMIT=1
START TRANSACTION



3，使用Savepoint
使用savepoint回滚难免有些性能消耗，一般可以用IF改写
savepoint的良好使用的场景之一是“嵌套事务”，你可能希望程序执行一个小的事务，但是不希望回滚外面更大的事务：

Java代码 复制代码
  1. CREATE PROCEDURE nested_tfer_funds   
  2.     (in_from_acct   INTEGER,   
  3.      in_to_acct     INTEGER,   
  4.      in_tfer_amount DECIMAL(8,2))   
  5. BEGIN   
  6.     DECLARE txn_error INTEGER DEFAULT 0;   
  7.   
  8.     DECLARE CONTINUE HANDLER FOR SQLEXCEPTION BEGIN   
  9.         SET txn_error=1;   
  10.     END   
  11.   
  12.     SAVEPINT savepint_tfer;   
  13.   
  14.     UPDATE account_balance   
  15.        SET balance=balance-in_tfer_amount   
  16.      WHERE account_id=in_from_acct;   
  17.   
  18.     IF txn_error THEN   
  19.         ROLLBACK TO savepoint_tfer;   
  20.         SELECT 'Transfer aborted';   
  21.     ELSE   
  22.         UPDATE account_balance   
  23.            SET balance=balance+in_tfer_amount   
  24.          WHERE account_id=in_to_acct;   
  25.   
  26.         IF txn_error THEN   
  27.             ROLLBACK TO savepoint_tfer;   
  28.             SELECT 'Transfer aborted';   
  29.   
  30.         END IF:   
  31.     END IF;   
  32. END;  
CREATE PROCEDURE nested_tfer_funds
    (in_from_acct   INTEGER,
     in_to_acct     INTEGER,
     in_tfer_amount DECIMAL(8,2))
BEGIN
    DECLARE txn_error INTEGER DEFAULT 0;

    DECLARE CONTINUE HANDLER FOR SQLEXCEPTION BEGIN
        SET txn_error=1;
    END

    SAVEPINT savepint_tfer;

    UPDATE account_balance
       SET balance=balance-in_tfer_amount
     WHERE account_id=in_from_acct;

    IF txn_error THEN
        ROLLBACK TO savepoint_tfer;
        SELECT 'Transfer aborted';
    ELSE
        UPDATE account_balance
           SET balance=balance+in_tfer_amount
         WHERE account_id=in_to_acct;

        IF txn_error THEN
            ROLLBACK TO savepoint_tfer;
            SELECT 'Transfer aborted';

        END IF:
    END IF;
END;



4，事务和锁
事务的ACID属性只能通过限制数据库的同步更改来实现，从而通过对修改数据加锁来实现。
直到事务触发COMMIT或ROLLBACK语句时锁才释放。
缺点是后面的事务必须等前面的事务完成才能开始执行，吞吐量随着等待锁释放的时间增长而递减。
MySQL/InnoDB通过行级锁来最小化锁竞争。这样修改同一table里其他行的数据没有限制，而且读数据可以始终没有等待。
可以在SELECT语句里使用FOR UPDATE或LOCK IN SHARE MODE语句来加上行级锁

Java代码 复制代码
  1. SELECT select_statement options [FOR UPDATE|LOCK IN SHARE MODE]  
SELECT select_statement options [FOR UPDATE|LOCK IN SHARE MODE]


FOR UPDATE会锁住该SELECT语句返回的行，其他SELECT和DML语句必须等待该SELECT语句所在的事务完成
LOCK IN SHARE MODE同FOR UPDATE，但是允许其他session的SELECT语句执行并允许获取SHARE MODE锁

死锁：
死锁发生于两个事务相互等待彼此释放锁的情景
当MySQL/InnoDB检查到死锁时，它会强制一个事务rollback并触发一条错误消息
对InnoDB而言，所选择的rollback的事务是完成工作最少的事务（所修改的行最少）

Java代码 复制代码
  1. mysql > CALL tfer_funds(1,2,300);   
  2. ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction   
mysql > CALL tfer_funds(1,2,300);
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction


死锁在任何数据库系统里都可能发生，但是对MySQL/InnoDB这种行级锁数据库而言可能性相对较少。
可以通过使用一致的顺序来锁row或table以及让事务保持尽可能短来减少死锁的频率。
如果死锁不容易debug，你可以向你的程序中添加一些逻辑来处理死锁并重试事务，但这部分代码多了以后很难维护
所以，比较好的避免死锁的方式是在做任何修改之前按一定的顺序添加行级锁，这样就能避免死锁:

Java代码 复制代码
  1. CREATE PROCEDURE tfer_funds3   
  2.     (from_account INT, to_account INT, tfer_amount NUMERIC(10,2))   
  3. BEGIN   
  4.     DECLARE local_account_id INT;   
  5.     DECLARE lock_cursor CURSOR FOR   
  6.         SELECT account_id   
  7.           FROM account_balance   
  8.          WHERE account_id IN (from_account, to_account)   
  9.          ORDER BY account_id   
  10.            FOR UPDATE;   
  11.   
  12.     START TRANSACTION;   
  13.   
  14.     OPEN lock_cursor;   
  15.     FETCH lock_cursor INTO local_account_id;   
  16.   
  17.     UPDATE account_balance   
  18.        SET balance=balance-tfer_amount   
  19.      WHERE account_id=from_account;   
  20.   
  21.     UPDATE account_balance   
  22.        SET balance=balance+tfer_amount   
  23.      WHERE account_id=to_account;   
  24.   
  25.     CLOSE lock_cursor;   
  26.   
  27.     COMMIT;   
  28. END;  
CREATE PROCEDURE tfer_funds3
    (from_account INT, to_account INT, tfer_amount NUMERIC(10,2))
BEGIN
    DECLARE local_account_id INT;
    DECLARE lock_cursor CURSOR FOR
        SELECT account_id
          FROM account_balance
         WHERE account_id IN (from_account, to_account)
         ORDER BY account_id
           FOR UPDATE;

    START TRANSACTION;

    OPEN lock_cursor;
    FETCH lock_cursor INTO local_account_id;

    UPDATE account_balance
       SET balance=balance-tfer_amount
     WHERE account_id=from_account;

    UPDATE account_balance
       SET balance=balance+tfer_amount
     WHERE account_id=to_account;

    CLOSE lock_cursor;

    COMMIT;
END;



设置死锁ttl: innodb_lock_wait_timeout，默认为50秒
如果你在一个事务中混合使用InnoDB和非InnoDB表，则MySQL不能检测到死锁，此时会抛出“lock wait timeuot”1205错误

乐观所和悲观锁策略：
悲观锁：在读取数据时锁住那几行，其他对这几行的更新需要等到悲观锁结束时才能继续
乐观所：读取数据时不锁，更新时检查是否数据已经被更新过，如果是则取消当前更新
一般在悲观锁的等待时间过长而不能接受时我们才会选择乐观锁
悲观锁的例子：

Java代码 复制代码
  1. CREATE PROCEDURE tfer_funds   
  2.        (from_account INT, to_account INT,tfer_amount NUMERIC(10,2),   
  3.         OUT status INT, OUT message VARCHAR(30))   
  4. BEGIN   
  5.     DECLARE from_account_balance NUMERIC(10,2);   
  6.   
  7.     START TRANSACTION;   
  8.   
  9.   
  10.     SELECT balance   
  11.       INTO from_account_balance   
  12.       FROM account_balance   
  13.      WHERE account_id=from_account   
  14.        FOR UPDATE;   
  15.   
  16.     IF from_account_balance>=tfer_amount THEN   
  17.   
  18.          UPDATE account_balance   
  19.             SET balance=balance-tfer_amount   
  20.           WHERE account_id=from_account;   
  21.   
  22.          UPDATE account_balance   
  23.             SET balance=balance+tfer_amount   
  24.           WHERE account_id=to_account;   
  25.          COMMIT;   
  26.   
  27.          SET status=0;   
  28.          SET message='OK';   
  29.     ELSE   
  30.          ROLLBACK;   
  31.          SET status=-1;   
  32.          SET message='Insufficient funds';   
  33.     END IF;   
  34. END;  
CREATE PROCEDURE tfer_funds
       (from_account INT, to_account INT,tfer_amount NUMERIC(10,2),
        OUT status INT, OUT message VARCHAR(30))
BEGIN
    DECLARE from_account_balance NUMERIC(10,2);

    START TRANSACTION;


    SELECT balance
      INTO from_account_balance
      FROM account_balance
     WHERE account_id=from_account
       FOR UPDATE;

    IF from_account_balance>=tfer_amount THEN

         UPDATE account_balance
            SET balance=balance-tfer_amount
          WHERE account_id=from_account;

         UPDATE account_balance
            SET balance=balance+tfer_amount
          WHERE account_id=to_account;
         COMMIT;

         SET status=0;
         SET message='OK';
    ELSE
         ROLLBACK;
         SET status=-1;
         SET message='Insufficient funds';
    END IF;
END;


乐观锁的例子：

Java代码 复制代码
  1. CREATE PROCEDURE tfer_funds   
  2.     (from_account INT, to_account INT, tfer_amount NUMERIC(10,2),   
  3.         OUT status INT, OUT message VARCHAR(30) )   
  4.   
  5. BEGIN   
  6.   
  7.     DECLARE from_account_balance    NUMERIC(8,2);   
  8.     DECLARE from_account_balance2   NUMERIC(8,2);   
  9.     DECLARE from_account_timestamp1 TIMESTAMP;   
  10.     DECLARE from_account_timestamp2 TIMESTAMP;   
  11.   
  12.     SELECT account_timestamp,balance   
  13.         INTO from_account_timestamp1,from_account_balance   
  14.             FROM account_balance   
  15.             WHERE account_id=from_account;   
  16.   
  17.     IF (from_account_balance>=tfer_amount) THEN   
  18.   
  19.         -- Here we perform some long running validation that   
  20.         -- might take a few minutes */   
  21.         CALL long_running_validation(from_account);   
  22.   
  23.         START TRANSACTION;   
  24.   
  25.         -- Make sure the account row has not been updated since   
  26.         -- our initial check   
  27.         SELECT account_timestamp, balance   
  28.             INTO from_account_timestamp2,from_account_balance2   
  29.             FROM account_balance   
  30.             WHERE account_id=from_account   
  31.             FOR UPDATE;   
  32.   
  33.         IF (from_account_timestamp1 <> from_account_timestamp2 OR   
  34.             from_account_balance    <> from_account_balance2)  THEN   
  35.             ROLLBACK;   
  36.             SET status=-1;   
  37.             SET message=CONCAT("Transaction cancelled due to concurrent update",   
  38.                 " of account"  ,from_account);   
  39.         ELSE   
  40.             UPDATE account_balance   
  41.                 SET balance=balance-tfer_amount   
  42.                 WHERE account_id=from_account;   
  43.   
  44.             UPDATE account_balance   
  45.                 SET balance=balance+tfer_amount   
  46.                 WHERE account_id=to_account;   
  47.   
  48.             COMMIT;   
  49.   
  50.             SET status=0;   
  51.             SET message="OK";   
  52.         END IF;   
  53.   
  54.     ELSE   
  55.         ROLLBACK;   
  56.         SET status=-1;   
  57.         SET message="Insufficient funds";   
  58.     END IF;   
  59. END$$  
CREATE PROCEDURE tfer_funds
    (from_account INT, to_account INT, tfer_amount NUMERIC(10,2),
        OUT status INT, OUT message VARCHAR(30) )

BEGIN

    DECLARE from_account_balance    NUMERIC(8,2);
    DECLARE from_account_balance2   NUMERIC(8,2);
    DECLARE from_account_timestamp1 TIMESTAMP;
    DECLARE from_account_timestamp2 TIMESTAMP;

    SELECT account_timestamp,balance
        INTO from_account_timestamp1,from_account_balance
            FROM account_balance
            WHERE account_id=from_account;

    IF (from_account_balance>=tfer_amount) THEN

        -- Here we perform some long running validation that
        -- might take a few minutes */
        CALL long_running_validation(from_account);

        START TRANSACTION;

        -- Make sure the account row has not been updated since
        -- our initial check
        SELECT account_timestamp, balance
            INTO from_account_timestamp2,from_account_balance2
            FROM account_balance
            WHERE account_id=from_account
            FOR UPDATE;

        IF (from_account_timestamp1 <> from_account_timestamp2 OR
            from_account_balance    <> from_account_balance2)  THEN
            ROLLBACK;
            SET status=-1;
            SET message=CONCAT("Transaction cancelled due to concurrent update",
                " of account"  ,from_account);
        ELSE
            UPDATE account_balance
                SET balance=balance-tfer_amount
                WHERE account_id=from_account;

            UPDATE account_balance
                SET balance=balance+tfer_amount
                WHERE account_id=to_account;

            COMMIT;

            SET status=0;
            SET message="OK";
        END IF;

    ELSE
        ROLLBACK;
        SET status=-1;
        SET message="Insufficient funds";
    END IF;
END$$



5，事务设计指南

Java代码 复制代码
  1. 1，保持事务短小   
  2. 2，尽量避免事务中rollback   
  3. 3，尽量避免savepoint   
  4. 4，默认情况下，依赖于悲观锁   
  5. 5，为吞吐量要求苛刻的事务考虑乐观锁   
  6. 6，显示声明打开事务   
  7. 7，锁的行越少越好，锁的时间越短越好  
分享到：
| 继承修饰符的问题
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    一个关于mysql 事务管理的介绍

    MySQL 事务管理是数据库操作的重要组成部分，特别是在处理关键数据和多步骤操作时，确保数据的一致性和完整性至关重要。事务提供了原子性、一致性、隔离性和持久性的保障，这四个特性通常被简称为ACID属性。 原子性...

    mysql事务管理操作详解

    本文实例讲述了mysql事务管理操作。分享给大家供大家参考，具体如下： 本文内容： 什么是事务管理 事务管理操作 回滚点 默认的事务管理 首发日期：2018-04-18 什么是事务管理： 可以把一系列要执行的操作称为...

    MySQL事务管理(教程).md

    一起学习讨论, 0分资源, 随便下

    基于mysql,SpringBoot 分布式事务例子

    在SpringBoot中配置MySQL事务管理，我们通常会使用DataSourceTransactionManager，它适用于单数据库事务。如果需要跨数据库的分布式事务，可以考虑使用Atomikos、Bitronix等开源的JTA实现。 接下来，我们将讨论如何...

    MySQL事务部分回滚-回滚到指定保存点.zip_MYSQL_begunfqh_detailrj2

    MySQL是世界上最流行的关系型数据库管理系统之一，其在处理大量数据和复杂事务方面表现优秀。在进行数据库操作时，事务管理是确保数据完整性和一致...建议仔细阅读这份文档，以加深对MySQL事务管理和保存点使用的理解。

    MySQL知识总结思维导图

    压缩包内包含MySQL数据库基础、MySQL库的操作、MySQL表的操作（DDL）、MySQL数据类型、MySQL表的约束、MySQL基本查询（DML）、MySQL内置函数、MySQL复合查询、MySQL内外连接、MySQL索引特性、MySQL事务管理、MySQL...

    MySQL事务隔离级别

    MySQL事务隔离级别是数据库管理系统中一个非常重要的概念，它关系到数据的一致性和并发性能。在MySQL中，事务被用于确保数据库操作的原子性、一致性、隔离性和持久性（ACID特性）。事务隔离级别主要涉及四个方面：读...

    mysql事务学习资料(PPT+源码)

    在这个"mysql事务学习资料(PPT+源码)"中，你将深入理解MySQL事务的概念、类型、特性和实际应用。 1. **事务概念**：在数据库中，事务是一系列操作的集合，这些操作要么全部成功，要么全部回滚，以保持数据的一致性...

    Maven + spring + mybatis + mysql + 事务管理

    在企业级Java开发中，"Maven + Spring + MyBatis + MySQL + 事务管理"是一个常见的技术栈组合，它们各自扮演着不同的角色，构建出高效、稳定的后端系统。 **Maven** 是一个项目管理和综合工具，它帮助开发者管理...

    mysql分布式事务实现 MySQL XA pdf

    除了通过标准的XA接口实现分布式事务外，MySQL还提供了内部的XA支持，这意味着开发者可以直接在MySQL服务器内部使用XA功能，而无需依赖外部的事务管理器。 #### 九、总结 本文详细介绍了MySQL如何通过XA协议实现...

    企业日常事务管理系统MySQL.zip_MYSQL_javaweb_事务管理系统

    本文将深入探讨MySQL在数据库管理中的作用，JavaWeb的基本概念以及如何构建一个事务管理系统。 首先，MySQL是一款开源、免费的关系型数据库管理系统，它具有高性能、高可靠性和易于使用的特性。在企业日常事务管理...

    jdbc+spring+mysql事务理解和分析

    以下是对`jdbc+spring+mysql事务理解和分析`的详细说明： 1. **原子性(Atomicity)**：这是事务的基本特性，表示事务中的所有操作要么全部成功，要么全部回滚。如果在事务执行过程中发生错误，数据库会撤销所有已...

    mysql事务处理用法与实例详解

    ### MySQL事务处理用法与实例详解 #### 一、事务的概念及重要性 在数据库管理中，事务（Transaction）是指一系列作为一个整体的操作序列。这些操作要么全部成功，要么全部失败，不能只执行其中的一部分。事务处理...

    MySQL多表查询、事务和管理用户及授权

    本文将深入探讨MySQL中的多表查询、事务处理以及用户管理和权限授权。 **一、多表查询** 在数据库设计中，往往需要处理多个相关表的数据。MySQL提供了多种多表查询方法，包括： 1. **JOIN操作**：JOIN允许你将两...

    Mysql事务的基本使用-基本原理及特点ACID

    ### MySQL 事务的基本...通过对MySQL事务的理解和掌握，我们可以更好地利用其强大的功能来提高应用程序的稳定性和可靠性。通过本篇文章的学习，相信读者已经对MySQL事务的基本原理、特点以及使用方法有了全面的认识。

    mysql第九章.pdf

    MySQL数据库应用与开发中，事务管理和锁机制...总的来说，MySQL事务管理与锁机制的相关知识点是数据库应用开发和管理中不可或缺的核心内容。正确理解和应用这些知识点，对于构建高效、稳定、安全的数据库应用至关重要。

    Spring+Mybatis+MySql+Maven 简单的事务管理案例.rar

    这个"Spring+Mybatis+MySql+Maven 简单的事务管理案例"是一个典型的Java Web项目，旨在演示如何在这些技术之间集成并实现事务管理。下面将详细讲解这四个技术及其在事务管理中的应用。 **Spring框架** 是一个全面的...

Magicbox
Global site tag (gtag.js) - Google Analytics