精华内容
下载资源
问答
  • 并发的事务管理注意事项

    千次阅读 2017-06-07 18:03:35
    如果开发的系统是高并发的话,声明式事务管理尽量使用注解的方式:@Transactional使用注解控制事务方法的优点: * 1:开发团队达成一致约定,明确标注事务方法的编程风格 * 2:保证事务方法的执行时间尽可能短,...

    如果开发的系统是高并发的话,声明式事务管理尽量使用注解的方式:

    @Transactional

    使用注解控制事务方法的优点:

    • 1:开发团队达成一致约定,明确标注事务方法的编程风格
    • 2:保证事务方法的执行时间尽可能短,不要穿插其他网络操作。
    • 3:不是所有的方法都需要事务,如只有一条操作,只读操作不需要事务管理。
    展开全文
  • 数据库学习笔记7 并发控制

    千次阅读 2018-12-23 21:43:08
    并发执行的优点 改善系统的资源利用率 减少短事务的等待时间 事务并发引起的问题 读脏数据 脏数据(dirty data)是对未提交事务所写数据的统称。 若脏读就造成了数据库的不一致状态,应严格禁止。 若脏读带来的影响...

    什么是事务并发

    • I/O与CPU等可以并行交叉运行
    • 并发执行的优点
      改善系统的资源利用率
      减少短事务的等待时间

    事务并发引起的问题

    • 读脏数据
      脏数据(dirty data)是对未提交事务所写数据的统称。
      在这里插入图片描述
      若脏读就造成了数据库的不一致状态,应严格禁止。
      若脏读带来的影响足够小,偶尔可读一次脏数据,它可以提高并发性,减少事务的等待时间
    • 不可重复读(unrepeatable read)
      事务T1的两次读取数据之间,其它事务修改了它要读取的数据,以致两次读到的值不同
      在事务串行执行时,不会出现此现象
      在这里插入图片描述
    • 丢失更新(lost update)
      由两个事务对同一数据并发地写入引起
      在这里插入图片描述

    可串行化

    事务在运行中不受其它事务干扰的方法(保持隔离性):
    串行:
    每个事务依次顺序执行
    并行但控制:
    事务之间并发执行,DBMS调整事务的调度,使其运行结果与一次只执行一个事务的结果相同

    可串行化调度

    调度是可串行化的:多个事务交叉调度的结果与某一个串行调度的结果相同
    DBMS认为事务串行调度的结果保持了数据库的一致性,都是正确的
    一个调度如果是可串行化的,系统认为其调度是一个正确的调度,保持了数据库的一致性

    冲突可串行化

    若一个调度冲突等价于一个串行调度,则该调度是冲突可串行化的。
    例如

    调度S= R1(A) W1(A) R2(A) W2(A) R1(B) W1(B) R2(B) W2(B)
    R1(B)与W2(A)指令不冲突,可以交换执行顺序;
    R1(B)与R2(A)指令不冲突,可以交换执行顺序;
    W1(B)与W2(A)指令不冲突,可以交换执行顺序;
    W1(B)与R2(A)指令不冲突,可以交换执行顺序。
    调度S’= R1(A) W1(A) R1(B) W1(B) R2(A) W2(A) R2(B) W2(B)
    

    调度S’是一个串行调度。
    调度S等价于串行调度S’,是冲突可串行化的。

    视图等价

    对同一事务集,如果两个调度S1和S2在任何时候都保证每个事务读取相同的值,写入数据库的最终状态也是一样的,则称调度S1和S2视图等价。

    如果某个调度视图等价于一个串行调度,则称这个调度是视图可串行化的
    如果调度是冲突可串行化的,则该调度一定是视图可串行化的。但反过来未必成立。
    举例
    设调度S1= R1(A) W3(A) R2(B) W1(B)
    经过非冲突调整,S2 = R2(B) R1(A) W1(B) W3(A)
    调度S1和调度S2是冲突等价的。
    又因为调度S2为一串行调度,因此调度S1是冲突可串行化的。
    对于调度S1和S2,事务T1读取的A、事务T2读取的B都是数据库的初始值;数据库最终的A、B值都是由事务T3和T1写入的。
    因此,调度S1和S2是视图可串行化的。

    可串行化的判定

    判定一个调度是否是冲突可串行化的,可以使用前驱图(precedence graph)
    若前驱图中存在环,则表示调度S是不可串行化的。
    反之,若前驱图中不存在环,表示调度S是冲突可串行化的,可用拓扑排序得到调度S 的一个等价的串行调度。

    基于锁的管理

    锁相容性

    • 锁的类型
      共享锁(S锁):如果事务Ti申请到数据项Q 的共享锁,则Ti可以读数据项Q,但不能写Q。
      排它锁(X锁):如果事务Ti申请到数据项Q 的排它锁,则Ti可以读数据项Q,也可以写Q。
      在这里插入图片描述

    申请锁

    在这里插入图片描述
    T1,T2:更新后立即释放锁,可能脏读。
    T3,T4:事务的最后释放锁,避免脏读和确保可串行性。但降低并发度
    T5,T6:相互等待出现死锁

    2P协议

    两段锁协议(two-phase locking protocol,2PL)是指所有事务分两个阶段提出加锁和解锁申请:
    增长阶段(growing phase):在对任何数据进行读、写操作之前,首先申请并获得该数据的封锁;
    收缩阶段(shrinking phase):在释放一个封锁后,事务不再申请和获得其它的任何封锁。
    两段锁协议是保证冲突可串行化的充分条件,但该协议不保证不发生死锁。

    严格2P协议

    2p协议存在级联回滚现象
    严格两阶段锁

    • 除要求满足两段锁协议规定外,还要求事务的排它锁必须在事务提交之后释放。
    • 解决级联回滚问题
    • 避免了脏读和丢失修改的问题。

    强两阶段锁

    除要求满足两段锁协议规定外,还要求事务的所有锁都必须在事务提交之后释放。
    进一步解决数据项不能重复读的问题

    更新锁

    锁的升级有可能使得出现死锁的概率加大
    更新锁只允许事务读取数据项而不能修改数据项
    系统允许更新锁升级,而不允许共享锁升级

    展开全文
  • 数据库引擎和事务

    2021-02-10 14:26:28
    +指事务必须使数据库从一个一致性状态变换到另一个一致性状态,也就是说一个事务执行之前和执行之后都必须处于一致性状态。 隔离性 +当多个用户并发访问数据库时,比如操作同一张表时,数据库为每一个用户开启

    InnoDB引擎
    链接: B+、B-树.

    数据库引擎
    MyISAM是MySQL的默认数据库引擎(5.5版之前)
    优点
    性能佳、效率高
    缺点
    不支持事务处理(transaction);
    不安全
    使用的是B-树,二级索引

    事物
    四大特性ACID

    原子性
    +指事务包含的所有操作要么全部成功,要么全部失败回滚

    一致性
    +指事务必须使数据库从一个一致性状态变换到另一个一致性状态,也就是说一个事务执行之前和执行之后都必须处于一致性状态。

    隔离性
    +当多个用户并发访问数据库时,比如操作同一张表时,数据库为每一个用户开启的事务,不能被其他事务的操作所干扰,多个并发事务之间要相互隔离。

    持久性
    +指一个事务一旦被提交了,那么对数据库中的数据的改变就是永久性的,即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

    为什么要有事物
    +因为进程不能上锁,所以只能在数据库里直接限制
    +不考虑事物的隔离性,会发生的问题

    脏读
    +指在一个事务处理过程里读取了另一个未提交的事务中的数据。

    不可重复度
    +指在对于数据库中的某个数据,一个事务范围内多次查询却返回了不同的数据值,这是由于在查询间隔,被另一个事务修改并提交了。

    幻读
    +是事务非独立执行时发生的一种现象
    +幻读和不可重复读都是读取了另一条已经提交的事务(这点就脏读不同),所不同的是不可重复读查询的都是同一个数据项,而幻读针对的是一批数据整体(比如数据的个数)。
    +A插入数据,B修改提交后,发现没有达到预期的效果

    四大隔离级别

    Serializable (串行化)
    +可以避免脏读、不可重复读、幻读的发生
    Repeatable read (可重复读)
    +可以避免脏读、不可重复读的发生
    +也是MySQL默认的隔离级别
    Read committed (读已提交)
    +可以避免脏读的发生
    Read uncommitted (读未提交)
    +最低级别,任何情况都无法保证

    展开全文
  • DISCARD 取消事务,放弃执行事务块内所有命令。 EXEC 执行所有事务块内命令 。 MULTI 标记一个事务块开始 。 UNWATCH 取消 WATCH 命令对所有 key 监视。 WATCH key [key ...] 监视一个(或多个) key ,...
  • 18.1.2 Lua的优点 / 361 18.1.3 什么是ngx_lua / 361 18.1.4 开发环境 / 362 18.1.5 OpenResty生态 / 362 18.1.6 场景 / 362 18.2 基于OpenResty的常用架构模式 / 363 18.3 如何使用OpenResty开发Web应用 / 371 18.4...
  • 并发控制是与数据库一起使用概念,可确保并发执行数据库事务而不会破坏数据完整性。 关于此概念及其实现方法有很多理论和不同方法,但是我们将简要介绍PostgreSQL和MySQL(使用InnoDB时)处理它方式,以及在高...

    并发控制是与数据库一起使用的概念,可确保并发执行数据库事务而不会破坏数据完整性。

    关于此概念及其实现方法有很多理论和不同方法,但是我们将简要介绍PostgreSQLMySQL(使用InnoDB时)处理它的方式,以及在高并发系统中可能出现的常见问题:死锁(deadlock)。

    这些引擎通过使用称为MVCC(多版本并发控制)的方法来实现并发控制。在此方法中,当更新项目时,更改不会覆盖原始数据,而是将创建该项目的新版本(包含更改)。因此,我们将存储该项目的多个版本。

    该模型的主要优点之一是为查询(读取)数据而获取的锁与为写入数据而获取的锁不冲突,因此读取永远不会阻止写入,而写入永远不会阻止读取。

    但是,如果存储了同一项目的多个版本,那么交易将看到哪个版本?为了回答这个问题,我们需要回顾事务隔离的概念。事务指定隔离级别,该级别定义一个事务必须与其他事务进行的资源或数据修改相隔离的程度,此程度与事务生成的锁定直接相关,因此可以在事务中指定级别,它可以确定一个正在运行的事务对其他正在运行的事务的影响。

    这是一个非常有趣且冗长的主题,尽管我们不会在此博客中介绍太多细节。我们建议使用PostgreSQLMySQL官方文档以进一步阅读该主题。

    那么,在处理死锁时为什么要进入上述主题?因为sql命令将自动获取锁以确保MVCC行为,并且获取的锁类型取决于定义的事务隔离。

    有几种类型的锁(关于PostgreSQLMySQL的另一个漫长而有趣的主题),但是,关于锁的重要一点是锁之间如何相互作用(最准确地说,是如何发生冲突)。这是为什么?因为两个事务不能同时在同一对象上持有冲突模式的锁。一个非次要的细节,一旦获得,通常会一直持有锁直到交易结束。

    这是PostgreSQL示例,说明锁定类型如何相互冲突:

    PostgreSQL锁定类型冲突
    PostgreSQL锁定类型冲突

    对于MySQL

    MySQL锁定类型冲突
    MySQL锁定类型冲突

    X =排他锁IX =意图排他锁
    S =共享锁IS =意图共享锁

    那么,当我有两个正在运行的事务要同时对同一个对象持有冲突锁时会发生什么?其中一个将获得锁,而另一个将必须等待。

    因此,现在我们可以真正了解僵局期间发生的情况。

    那么什么是死锁?您可以想象,数据库死锁有几个定义,但是我喜欢以下内容以简化操作。

    数据库死锁是一种情况,其中两个或多个事务正在等待彼此放弃锁。

    因此,例如,以下情况将导致我们陷入死锁:

    死锁示例
    死锁示例

    在此,应用程序A锁定表1第1行以进行更新。

    同时,应用程序B锁定表2第2行。

    现在,应用程序A需要在表2行2上获得锁,以继续执行并完成事务,但是由于它由应用程序B持有,因此它无法获得该锁。应用程序A需要等待应用程序B释放它。 。

    但是应用程序B需要获得对表1第1行的锁定,以便继续执行并完成事务,但是由于它由应用程序A持有,因此它无法获得该锁定。

    因此,这里我们处于死锁。应用程序A在等待应用程序B拥有的资源以完成操作,而应用程序B在等待应用程序A拥有的资源。那么,如何继续?数据库引擎将检测死锁并杀死其中一个事务,解除对另一个事务的阻塞,并在被杀死的事务上引发死锁错误。

    让我们检查一些PostgreSQL和MySQL死锁示例:

    PostgreSQL

    假设我们有一个测试数据库,其中包含来自世界各国的信息。

    world=# SELECT code,region,population FROM country WHERE code IN ('NLD','AUS');
    code |          region           | population
    ------+---------------------------+------------
    NLD  | Western Europe            |   15864000
    AUS  | Australia and New Zealand |   18886000
    (2 rows)

    我们有两个会话要更改数据库。

    第一个会话将修改NLD代码的区域字段,以及AUS代码的填充字段。

    第二个会话将修改AUS代码的区域字段和NLD代码的填充字段。

    表格数据:

    code: NLD
    region: Western Europe
    population: 15864000
    code: AUS
    region: Australia and New Zealand
    population: 18886000

    会话1:

    world=# BEGIN;
    BEGIN
    world=# UPDATE country SET region='Europe' WHERE code='NLD';
    UPDATE 1

    会话2:

    world=# BEGIN;
    BEGIN
    world=# UPDATE country SET region='Oceania' WHERE code='AUS';
    UPDATE 1
    world=# UPDATE country SET population=15864001 WHERE code='NLD';

    会话2将挂起,等待会话1完成。

    会话1:

    world=# UPDATE country SET population=18886001 WHERE code='AUS';
    
    ERROR:  deadlock detected
    DETAIL:  Process 1181 waits for ShareLock on transaction 579; blocked by process 1148.
    Process 1148 waits for ShareLock on transaction 578; blocked by process 1181.
    HINT:  See server log for query details.
    CONTEXT:  while updating tuple (0,15) in relation "country"

    在这里,我们陷入死锁。系统检测到死锁并终止了会话1。

    会话2:

    world=# BEGIN;
    BEGIN
    world=# UPDATE country SET region='Oceania' WHERE code='AUS';
    UPDATE 1
    world=# UPDATE country SET population=15864001 WHERE code='NLD';
    UPDATE 1

    并且我们可以检查第二个会话在检测到死锁并且会话1被杀死之后(因此,锁已释放)正确完成。

    要获取更多详细信息,我们可以在PostgreSQL服务器中查看日志:

    2018-05-16 12:56:38.520 -03 [1181] ERROR:  deadlock detected
    2018-05-16 12:56:38.520 -03 [1181] DETAIL:  Process 1181 waits for ShareLock on transaction 579; blocked by process 1148.
           Process 1148 waits for ShareLock on transaction 578; blocked by process 1181.
           Process 1181: UPDATE country SET population=18886001 WHERE code='AUS';
           Process 1148: UPDATE country SET population=15864001 WHERE code='NLD';
    2018-05-16 12:56:38.520 -03 [1181] HINT:  See server log for query details.
    2018-05-16 12:56:38.520 -03 [1181] CONTEXT:  while updating tuple (0,15) in relation "country"
    2018-05-16 12:56:38.520 -03 [1181] STATEMENT:  UPDATE country SET population=18886001 WHERE code='AUS';
    2018-05-16 12:59:50.568 -03 [1181] ERROR:  current transaction is aborted, commands ignored until end of transaction block

    在这里,我们将能够看到在死锁中检测到的实际命令。

    MySQL

    为了模拟MySQL中的死锁,我们可以执行以下操作。

    与PostgreSQL一样,假设我们有一个测试数据库,其中包含有关演员和电影的信息。

    mysql> SELECT first_name,last_name FROM actor WHERE actor_id IN (1,7);
    +------------+-----------+
    | first_name | last_name |
    +------------+-----------+
    | PENELOPE   | GUINESS   |
    | GRACE      | MOSTEL    |
    +------------+-----------+
    2 rows in set (0.00 sec)

    我们有两个要更改数据库的过程。

    第一个会话将为actor_id 1修改字段first_name,为actor_id 7修改字段last_name。

    第二个会话将为actor_id 7修改字段first_name,为actor_id 1修改字段last_name。

    表格数据:

    actor_id: 1
    first_name: PENELOPE
    last_name: GUINESS
    actor_id: 7
    first_name: GRACE
    last_name: MOSTEL

    会话1:

    mysql> set autocommit=0;
    Query OK, 0 rows affected (0.00 sec)
    mysql> BEGIN;
    Query OK, 0 rows affected (0.00 sec)
    mysql> UPDATE actor SET first_name='GUINESS' WHERE actor_id='1';
    Query OK, 1 row affected (0.01 sec)
    Rows matched: 1  Changed: 1  Warnings: 0

    会话2:

    mysql> set autocommit=0;
    Query OK, 0 rows affected (0.00 sec)
    mysql> BEGIN;
    Query OK, 0 rows affected (0.00 sec)
    mysql> UPDATE actor SET first_name='MOSTEL' WHERE actor_id='7';
    Query OK, 1 row affected (0.00 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    mysql> UPDATE actor SET last_name='PENELOPE' WHERE actor_id='1';

    会话2将挂起,等待会话1完成。

    会话1:

    mysql> UPDATE actor SET last_name='GRACE' WHERE actor_id='7';
    
    ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

    在这里,我们陷入死锁。系统检测到死锁并终止了会话1。

    会话2:

    mysql> set autocommit=0;
    Query OK, 0 rows affected (0.00 sec)
    mysql> BEGIN;
    Query OK, 0 rows affected (0.00 sec)
    mysql> UPDATE actor SET first_name='MOSTEL' WHERE actor_id='7';
    Query OK, 1 row affected (0.00 sec)
    Rows matched: 1  Changed: 1  Warnings: 0
    mysql> UPDATE actor SET last_name='PENELOPE' WHERE actor_id='1';
    Query OK, 1 row affected (8.52 sec)
    Rows matched: 1  Changed: 1  Warnings: 0

    正如我们在PostgreSQL中看到的那样,我们在错误中可以看到,两个进程之间存在死锁。

    有关更多详细信息,我们可以使用命令SHOW ENGINE INNODB STATUS \ G:

    mysql> SHOW ENGINE INNODB STATUS\G
    ------------------------
    LATEST DETECTED DEADLOCK
    ------------------------
    2018-05-16 18:55:46 0x7f4c34128700
    *** (1) TRANSACTION:
    TRANSACTION 1456, ACTIVE 33 sec starting index read
    mysql tables in use 1, locked 1
    LOCK WAIT 3 lock struct(s), heap size 1136, 2 row lock(s), undo log entries 1
    MySQL thread id 54, OS thread handle 139965388506880, query id 15876 localhost root updating
    UPDATE actor SET last_name='PENELOPE' WHERE actor_id='1'
    *** (1) WAITING FOR THIS LOCK TO BE GRANTED:
    RECORD LOCKS space id 23 page no 3 n bits 272 index PRIMARY of table `sakila`.`actor` trx id 1456 lock_mode X locks rec but not gap waiting
    Record lock, heap no 2 PHYSICAL RECORD: n_fields 6; compact format; info bits 0
    0: len 2; hex 0001; asc   ;;
    1: len 6; hex 0000000005af; asc       ;;
    2: len 7; hex 2d000001690110; asc -   i  ;;
    3: len 7; hex 4755494e455353; asc GUINESS;;
    4: len 7; hex 4755494e455353; asc GUINESS;;
    5: len 4; hex 5afca8b3; asc Z   ;;
    
    *** (2) TRANSACTION:
    TRANSACTION 1455, ACTIVE 47 sec starting index read, thread declared inside InnoDB 5000
    mysql tables in use 1, locked 1
    3 lock struct(s), heap size 1136, 2 row lock(s), undo log entries 1
    MySQL thread id 53, OS thread handle 139965267871488, query id 16013 localhost root updating
    UPDATE actor SET last_name='GRACE' WHERE actor_id='7'
    *** (2) HOLDS THE LOCK(S):
    RECORD LOCKS space id 23 page no 3 n bits 272 index PRIMARY of table `sakila`.`actor` trx id 1455 lock_mode X locks rec but not gap
    Record lock, heap no 2 PHYSICAL RECORD: n_fields 6; compact format; info bits 0
    0: len 2; hex 0001; asc   ;;
    1: len 6; hex 0000000005af; asc       ;;
    2: len 7; hex 2d000001690110; asc -   i  ;;
    3: len 7; hex 4755494e455353; asc GUINESS;;
    4: len 7; hex 4755494e455353; asc GUINESS;;
    5: len 4; hex 5afca8b3; asc Z   ;;
    
    *** (2) WAITING FOR THIS LOCK TO BE GRANTED:
    RECORD LOCKS space id 23 page no 3 n bits 272 index PRIMARY of table `sakila`.`actor` trx id 1455 lock_mode X locks rec but not gap waiting
    Record lock, heap no 202 PHYSICAL RECORD: n_fields 6; compact format; info bits 0
    0: len 2; hex 0007; asc   ;;
    1: len 6; hex 0000000005b0; asc       ;;
    2: len 7; hex 2e0000016a0110; asc .   j  ;;
    3: len 6; hex 4d4f5354454c; asc MOSTEL;;
    4: len 6; hex 4d4f5354454c; asc MOSTEL;;
    5: len 4; hex 5afca8c1; asc Z   ;;
    
    *** WE ROLL BACK TRANSACTION (2)

    在标题“最新检测到的死锁”下,我们可以看到死锁的详细信息。

    要在mysql错误日志中查看死锁的详细信息,我们必须在数据库中启用选项innodb_print_all_deadlocks。

    mysql> set global innodb_print_all_deadlocks=1;
    Query OK, 0 rows affected (0.00 sec)

    MySQL日志错误:

    2018-05-17T18:36:58.341835Z 12 [Note] InnoDB: Transactions deadlock detected, dumping detailed information.
    2018-05-17T18:36:58.341869Z 12 [Note] InnoDB:
    *** (1) TRANSACTION:
     
    TRANSACTION 1812, ACTIVE 42 sec starting index read
    mysql tables in use 1, locked 1
    LOCK WAIT 3 lock struct(s), heap size 1136, 2 row lock(s), undo log entries 1
    MySQL thread id 11, OS thread handle 140515492943616, query id 8467 localhost root updating
    UPDATE actor SET last_name='PENELOPE' WHERE actor_id='1'
    2018-05-17T18:36:58.341945Z 12 [Note] InnoDB: *** (1) WAITING FOR THIS LOCK TO BE GRANTED:
     
    RECORD LOCKS space id 23 page no 3 n bits 272 index PRIMARY of table `sakila`.`actor` trx id 1812 lock_mode X locks rec but not gap waiting
    Record lock, heap no 204 PHYSICAL RECORD: n_fields 6; compact format; info bits 0
    0: len 2; hex 0001; asc   ;;
    1: len 6; hex 000000000713; asc       ;;
    2: len 7; hex 330000016b0110; asc 3   k  ;;
    3: len 7; hex 4755494e455353; asc GUINESS;;
    4: len 7; hex 4755494e455353; asc GUINESS;;
    5: len 4; hex 5afdcb89; asc Z   ;;
     
    2018-05-17T18:36:58.342347Z 12 [Note] InnoDB: *** (2) TRANSACTION:
     
    TRANSACTION 1811, ACTIVE 65 sec starting index read, thread declared inside InnoDB 5000
    mysql tables in use 1, locked 1
    3 lock struct(s), heap size 1136, 2 row lock(s), undo log entries 1
    MySQL thread id 12, OS thread handle 140515492677376, query id 9075 localhost root updating
    UPDATE actor SET last_name='GRACE' WHERE actor_id='7'
    2018-05-17T18:36:58.342409Z 12 [Note] InnoDB: *** (2) HOLDS THE LOCK(S):
     
    RECORD LOCKS space id 23 page no 3 n bits 272 index PRIMARY of table `sakila`.`actor` trx id 1811 lock_mode X locks rec but not gap
    Record lock, heap no 204 PHYSICAL RECORD: n_fields 6; compact format; info bits 0
    0: len 2; hex 0001; asc   ;;
    1: len 6; hex 000000000713; asc       ;;
    2: len 7; hex 330000016b0110; asc 3   k  ;;
    3: len 7; hex 4755494e455353; asc GUINESS;;
    4: len 7; hex 4755494e455353; asc GUINESS;;
    5: len 4; hex 5afdcb89; asc Z   ;;
     
    2018-05-17T18:36:58.342793Z 12 [Note] InnoDB: *** (2) WAITING FOR THIS LOCK TO BE GRANTED:
     
    RECORD LOCKS space id 23 page no 3 n bits 272 index PRIMARY of table `sakila`.`actor` trx id 1811 lock_mode X locks rec but not gap waiting
    Record lock, heap no 205 PHYSICAL RECORD: n_fields 6; compact format; info bits 0
    0: len 2; hex 0007; asc   ;;
    1: len 6; hex 000000000714; asc       ;;
    2: len 7; hex 340000016c0110; asc 4   l  ;;
    3: len 6; hex 4d4f5354454c; asc MOSTEL;;
    4: len 6; hex 4d4f5354454c; asc MOSTEL;;
    5: len 4; hex 5afdcba0; asc Z   ;;
     
    2018-05-17T18:36:58.343105Z 12 [Note] InnoDB: *** WE ROLL BACK TRANSACTION (2)

    考虑到上面我们了解的死锁发生原因,您可以看到在数据库方面没有很多事情可以避免死锁。无论如何,作为DBA,我们有责任实际捕获它们,对其进行分析并向开发人员提供反馈。

    实际上,这些错误是每个应用程序所特有的,因此您需要一个一个地检查它们,并且没有指南告诉您如何解决此问题。记住这一点,您可以找一些东西。

    搜索长时间运行的事务。由于锁通常保持到事务结束,因此事务越长,对资源的锁定就越长。如果可能,请尝试将长期运行的事务拆分为较小/较快的事务。

    有时实际上不可能拆分事务,因此工作应集中于每次尝试以一致的顺序执行那些操作,以便事务形成定义明确的队列,并且不会死锁。

    您还可以建议的一种解决方法是,将重试逻辑添加到应用程序中(当然,首先尝试解决根本问题),这样,如果发生死锁,应用程序将再次运行相同的命令。

    检查使用的隔离级别,有时您可以通过更改它们来尝试。查找诸如SELECT FOR UPDATE和SELECT FOR SHARE之类的命令,因为它们会生成显式锁,并评估是否确实需要它们,或者您可以使用较旧的数据快照。如果无法删除这些命令,您可以尝试的一件事是使用较低的隔离级别,例如READ COMMITTED。

    当然,请始终将精选的索引添加到表中。然后,您的查询需要扫描更少的索引记录,并因此设置更少的锁。

    在较高的级别上,作为DBA,您可以采取一些预防措施来最大程度地减少锁定。为了命名一个示例(在本例中是PostgreSQL),您可以避免在添加列的同一命令中添加默认值。更改表将获得非常积极的锁定,并为其设置默认值实际上将更新具有空值的现有行,从而使该操作花费了很长时间。因此,如果将此操作拆分为几个命令,添加列,添加默认值,更新空值,则可以最大程度地减少锁定影响。

    当然,DBA会从实践中获得很多类似的技巧(同时创建索引,在添加pk之前分别创建pk索引,依此类推),但是重要的是学习和理解这种“思维方式”。 ”,并且始终将我们正在执行的操作的锁定影响最小化。

    展开全文
  • 常用的存储引擎 1、MyISAM 优点:文本索引 缺点:不支持事务的完整...适合场景: 对于财务系统,那么经常修改或者插入数据的操作的表,对事务完整性要求高,支持事务的提交、回滚操作,执行并发场景。 3、Memor
  • MysqlMVCC

    2018-08-02 16:17:00
    引擎: InnoDB 隔离级别:REPEATABLE READ,...(3)行删除时间:第二个隐藏列,记录执行删除该行的事务号,也就是记录哪个事务删除它 优点:是大多数读操作不用加锁,提高并发能力 缺点:因为每行都要进行版...
  • 各种锁机制分析

    2020-06-18 22:50:03
    1. synchronize 同步锁方案 缺点一:线程串行导致的性能问题,...缺点二:需要注意设置事务的隔离级别是Read Committed,否则并发情况下,另外的事务无法看到提交的数据,依然会导致超卖的问题。 缺点三:容易打满数
  • 即一个事务内部操作及使用数据对其他并发事务是隔离并发执行的各个事务之间不能互相干扰。(4)持续性(Durability ):指一个事务一旦提交,它对数据库中数据改变就应该是永久。接下来其他操作或故障...
  • 16恢复系统

    2017-02-28 01:23:20
    故障分类 事务故障 系统故障 介质故障 存储器分类 数据转储 静态转储 优点 缺点 动态转储 优点 ...优点 ...优点 ...优点 ...数据库维护两个物理块输出过程 ...数据库系统中存储块 块移动引发操作 ...执行
  • 1.Redis简介   1.1非关系型数据库特点 数据模型比较简单 需要灵活性更强IT系统 对数据库性能要求较高 不需要高度数据一致性 对于给定key,比较容易映射复杂值...ACID,指数据库事务正确执行的四个基...
  • DBProxy的优点 支持多语言MySQL客户端 读写分离 负载均衡 Slave故障感知与摘除(Master需要MHA等其他联动) 后端连接池 自定义SQL拦截与过滤 流量分组与控制 丰富的监控...
  • 文章目录SQL语句常用SQL语句(CRUD)SQL语句的执行顺序连接查询存储引擎InnoDBMyISAMInnoDB和MyISAM比较索引索引的优点索引的分类如何建立索引什么情况索引会失效MySQL索引结构B+树索引与B树的比较与红黑树的比较...
  • 总结如下:mysql 优点: 1、性能卓越服务稳定,很少出现异常宕机 2、因小巧安装复杂度低和使用方面以及执行速度快 3、开发入门门槛低 4、适合关系型数据表维护 5、有丰富sql语句和聚合函数以及多种数据类型 6、有...
  • 5.1、微服务和分布式数据管理问题 单体应用通常有一个单一关系型数据库。使用关系型数据库一个主要优点是你应用可以使用 ACID 事务,...隔离性(Isolation) — 即使事务并发执行,但它们看起来更像是串行执...
  • JSP具有以下的优点: 1、将业务层与表示层分离:使用JSP技术,网络开发人员可充分使用HTML来设计页面显示部分(如字体颜色等),并使用JSP指令或者JAVA程序片段来生成网页上的动态内容; 2、能够跨平台:JSP支持绝...
  • mysql 良好安全连接,自带查询解析,sql语句优化,使用读写锁(细化到行),事务隔离和多版本并发控制提高并发,完备的事务日志记录,强大存储引擎提供高效查询(表记录可达百万级)。如果是innerdb还可在崩溃后进行...
  • 这个及其简单 Mybatis负责较为复杂的查询boot-dubbo-service该项目依赖api和boot-dubbo-infrastructure它要实现api约定的接口,另外依赖boot-dubbo-infrastructure对不同数据表的操作以及对事务的操作boot-dubbo-...
  • 4.2.1 事务的基本概念 191 4.2.2 分布式事务处理、XA规范和 2PC协议 192 4.2.3 使用JTA全局事务保证多 数据库的一致性 193 4.3 事务隔离、传播属性的设置 198 4.3.1 并发访问和隔离 198 4.3.2 事务属性 199 4.4 EJB...
  • C#常见面试题

    2020-04-07 11:57:12
    记录一下最近C#的面试题 1.什么是事务?...SqlServer自动锁定特定记录、字段或文件,防止用户访问,以维护数据安全或防止并发数据操作问题,锁可以保证事务的完整性和并发性。 2.数据库索引,有什么优点? 索...
  • mysql性能优化

    2019-09-25 06:36:46
    mysql 良好安全连接,自带查询解析,sql语句优化,使用读写锁(细化到行),事务隔离和多版本并发控制提高并发,完备的事务日志记录,强大存储引擎提供高效查询(表记录可达百万级)。如果是innerdb还可在崩溃后...
  • 翻译过程中,译者感到此言不虚:作者从数据库基本概念到数据库建模,从如何运用规范化原则到如何做成实际数据库表,从如何保护数据库完整性到如何提高数据库性能,从数据库安全机制到并发事务控制,从...
  • c#面试题

    2016-01-04 10:28:00
    2.什么是事务?什么是锁? 答:事务是指一个工作单元,它包含了一组数据操作命令,并且所有的命令作为一...护数据安全或防止并发数据操作问题,锁可以保证事务的完整性和并发性。 3.什么是索引,有什么优点? ...
  • MySQL和数据库笔记

    2020-10-25 14:39:37
    数据库左连接与右连接MyISAM和InnoDB区别BTree索引 和 哈希索引什么是事务事务的四大特性并发事务带来哪些问题?事务隔离级别有哪些?MySQL的默认隔离级别是?大表优化一条SQL语句在MySQL中如何执行的 1. 索引 为什么...
  • 悲观锁比较悲观,认为并发大概率导致冲突,所以要加锁防止并发。乐观锁比较乐观,认为并发小概率...自旋锁的优点执行速度快,缺点是使用不当会导致CPU占用率高。此外,自旋锁还可以关注公平性和可重入性的问题。 ...
  • MySQL常用知识

    2019-03-03 18:01:00
    1.MySQL常用引擎有哪些?...优点:具有良好ACID特性(指数据库事务正确执行的四个基本要素缩写) 包含Atomicity原子性、Consistency一致性、Isolation隔离性、Durability持久性。 适用于高并发,更新...
  • 优点执行读取操作速度很快;不占用大量内存和存储资源; 缺点:不支持事务处理;不能容错; MYISAM 优点:在ISAM基础上,增加索引和字段管理大量功能;表格锁定机制,以优化多个并发的
  • 限流分布式锁信号量事务相比 Redis 事务来说,Lua 脚本有以下优点减少网络开销: 不使用 Lua 代码需要向 Redis 发送多次请求,而脚本只需一次即可,减少网络传输;原子操作:Redis 将整个脚本作为一个原子执行,...

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

并发执行事务的优点