【锁】Oracle锁系列

时间 2019-12-01

标签 oracle 系列栏目 Oracle 繁體版

原文原文链接

【锁】Oracle锁系列javascript

1 BLOG文档结构图

2 前言部分

2.1 导读和注意事项

各位技术爱好者，看完本文后，你能够掌握以下的技能，也能够学到一些其它你所不知道的知识，~O(∩_∩)O~：html

① 锁的概念、分类、及其模拟java

② 查询锁的视图及视图之间的关联sql

③ 锁的参数（DML_LOCKS、DDL_LOCK_TIMEOUT）数据库

④ FOR UPDATE及FOR UPDATE OF系列缓存

⑤ 带ONLINE和不带ONLINE建立索引的锁状况（是否阻塞DML操做）安全

⑥ 包或存过不能编译的解决方法服务器

⑦ ORA-08104解决方法微信

Tips：网络

① 本文在itpub（http://blog.itpub.net/26736162）、博客园(http://www.cnblogs.com/lhrbest)和微信公众号（xiaomaimiaolhr）上有同步更新。

② 文章中用到的全部代码、相关软件、相关资料及本文的pdf版本都请前往小麦苗的云盘下载，小麦苗的云盘地址见：http://blog.itpub.net/26736162/viewspace-1624453/。

③ 若网页文章代码格式有错乱，请下载pdf格式的文档来阅读。

④ 在本篇BLOG中，代码输出部分通常放在一行一列的表格中。其中，须要特别关注的地方我都用灰色背景和粉红色字体来表示，好比在下边的例子中，thread 1的最大归档日志号为33，thread 2的最大归档日志号为43是须要特别关注的地方；而命令通常使用黄色背景和红色字体标注；对代码或代码输出部分的注释通常采用蓝色字体表示。

List of Archived Logs in backup set 11

Thrd Seq Low SCN Low Time Next SCN Next Time

---- ------- ---------- ------------------- ---------- ---------

1 32 1621589 2015-05-29 11:09:52 1625242 2015-05-29 11:15:48

1 33 1625242 2015-05-29 11:15:48 1625293 2015-05-29 11:15:58

2 42 1613951 2015-05-29 10:41:18 1625245 2015-05-29 11:15:49

2 43 1625245 2015-05-29 11:15:49 1625253 2015-05-29 11:15:53

[ZHLHRDB1:root]:/>lsvg -o

T_XLHRD_APP1_vg

rootvg

[ZHLHRDB1:root]:/>

00:27:22 SQL> alter tablespace idxtbs read write;

====》2097152*512/1024/1024/1024=1G

本文若有错误或不完善的地方请你们多多指正，ITPUB留言或QQ皆可，您的批评指正是我写做的最大动力。

2.2 本文简介

有网友一直催着说发一些锁系列的文章，其实小麦苗一直对锁这块也没有完全去研究过，今年写书里边写到了锁的内容，干脆就完全把这一块整理了一下，如今分享给你们，如有错误，还请你们及时指正。

文章不少内容来源于网络或Concepts的内容，如有侵权还请联系小麦苗删除。

第二章锁

2.1 锁的基本概念

锁的定义：锁（lock）机制用于管理对共享资源的并发访问，用于多用户的环境下，能够保证数据库的完整性和一致性。锁是防止访问相同资源的事务之间的破坏性交互的机制。既能够是用户对象(例如表或行)，也能够是对用户不可见的系统对象(例如共享数据结构和数据字典行)。

锁的解释：当多个用户并发地存取数据时，在数据库中就会产生多个事务同时存取同一数据的状况。若对并发操做不加控制就可能会读取和存储不正确的数据，破坏数据库的完整性和一致性。当事务在对某个数据对象进行操做前，先向系统发出请求，对其加锁。加锁后事务就对该数据对象有了必定的控制。

锁的做用：在并发事务之间防止破坏性的交互做用，不须要用户的动做，自动使用最低的限制级别，在事务处理期间保持。

数据库是一个多用户使用的共享资源。当多个用户并发地存取数据时，在数据库中就会产生多个事务同时存取同一数据的状况。若对并发操做不加控制就可能会读取和存储不正确的数据，破坏数据库的一致性。

锁（lock）是防止访问相同资源（例如表或数据行等用户对象，或内存中的共享数据结构及数据字典等对用户不可见的系统对象）的事务产生破坏性交互的机制。

在任何状况下，Oracle 都可以自动地得到执行 SQL 语句所必须的全部锁，无需用户干预。Oracle 会尽量地减小锁产生的影响，从而最大程度地保证数据的并发访问能力，并确保数据一致性及错误恢复。同时，Oracle 也支持用户手工加锁的操做。

Oracle 历来不会升级锁，可是它会执行锁转换（lock conversion）或锁提高（lock promotion）。

A lock is a mechanism that prevents destructive interactions, which are interactions that incorrectly update data or incorrectly alter underlying data structures, between transactions accessing shared data. Locks play a crucial row in maintaining database concurrency and consistency.

锁是一种机制，用来防止多个共同访问共享数据的事务之间的破坏性交互，包括不正确地更新数据或不正确地更改基础数据结构。锁在维护数据库并发性和一致性当中扮演着一个关键的角色。

2.1.1 并发和并行

并发(concurrency)和并行(parallel)。并发意思是在数据库中有超过两个以上用户对一样的数据作修改，而并行的意思就是将一个任务分红不少小的任务，让每个小任务同时执行，最后将结果汇总到一块儿。因此说，锁产生的缘由就是并发，并发产生的缘由是由于系统和客户的须要。

2.1.2 使用锁

在单用户数据库中，锁不是必需的，由于只有一个用户在修改信息。可是，当多个用户在访问和修改数据时，数据库必须提供一种方法，以防止对同一数据进行并发修改。锁实现了如下重要的数据库需求：

v ·一致性

一个会话正在查看或更改的数据不能被其它会话更改，直到用户会话结束。

v ·完整性

数据和结构必须按正确的顺序反映对他们所作的全部更改。数据库经过其锁定机制，提供在多个事务之间的数据并发性、一致性、和完整性。锁定将自动执行，而且不须要用户操做。

执行SQL语句时，Oracle数据库自动获取所需的锁。例如，在数据库容许某个会话修改数据以前，该会话必须先锁定数据。锁给予该会话对数据的独占控制权，以便在释放该锁以前，任何其它事务都不能够修改被锁定的数据。

由于数据库的锁定机制与事务控制紧密地绑定在一块儿，应用程序设计人员只须要正确地定义事务，而数据库会自动管理锁定。

2.1.3 锁模式（Lock Modes）--共享和排它

Oracle数据库自动使用最低适用的限制级别，来提供最高程度的数据并发，但还能提供很是安全的数据完整性。限制级别越低、则有更多的可用数据供其余用户访问。相反，限制级别越高，则其它事务为获取其所需的锁类型就将遭受更多的限制。

在多用户的数据库系统中，Oracle使用两种模式的锁：

2.1.4 锁的持续时间

事务内各语句得到的锁在事务执行期内有效，以防止事务间破坏性的相互干扰，例如：脏读取（dirty read），无效地更新（lost update），以及其它并发事务中具备破坏性的 DDL 操做。若是某个事务中的 SQL 语句对数据进行了修改，只有在此事务提交后开始的事务才能看到前者修改的结果。

当用户提交（commit）或撤销（undo）一个事务后，Oracle 将释放此事务内各个 SQL 语句得到的锁。当用户在事务内回滚到某个保存点（savepoint）后，Oracle 也会释放此保存点后得到的锁。只有当前没有等待被锁资源的事务才能得到可用资源的锁。等待事务不会对可用资源加锁而是继续等待，直至拥有其所等待资源的事务完成提交或回滚。

2.2 显式锁定和隐式锁定

有两种类型：显式锁定和隐式锁定。Oracle锁被自动执行，而且不要求用户干预的锁为隐式锁。对于SQL语句隐式锁是必须的，依赖被请求的动做。隐式锁定除SELECT外，对全部的SQL语句都发生。用户也能够手动锁定数据，这是显式锁定。

隐式锁定：这是Oracle中使用最多的锁。一般用户没必要声明要对谁加锁，Oracle 自动能够为操做的对象加锁，这就是隐式锁定。

显式锁定：用户可使用命令明确的要求对某一对象加锁。显式锁定不多使用。

2.2.1 显式锁定

LOCK TABLE没有触发行锁，只有TM表锁。

LOCK TABLE TABLE_NAME IN ROW SHARE MODE NOWAIT; --2：RS

LOCK TABLE TABLE_NAME IN SHARE UPDATE MODE; --2：RS

LOCK TABLE TABLE_NAME IN ROW EXCLUSIVE MODE NOWAIT; --3：RX

LOCK TABLE TABLE_NAME IN SHARE MODE; --4：S

LOCK TABLE TABLE_NAME IN SHARE ROW EXCLUSIVE MODE; --5：SRX

LOCK TABLE TABLE_NAME IN EXCLUSIVE MODE NOWAIT; --6：X

2.2.2 隐式锁定

隐式锁定：

Select * from table_name……

Insert into table_name……

Update table_name……

Delete from table_name……

Select * from table_name for update

2.3 悲观锁和乐观锁

2.3.1 悲观锁

锁在用户修改以前就发挥做用：

Select ..for update（nowait)

Select * from tab1 for update

用户发出这条命令以后，oracle将会对返回集中的数据创建行级封锁，以防止其余用户的修改。

若是此时其余用户对上面返回结果集的数据进行dml或ddl操做都会返回一个错误信息或发生阻塞。

1：对返回结果集进行update或delete操做会发生阻塞。

2：对该表进行ddl操做将会报：Ora-00054:resource busy and acquire with nowait specified.

缘由分析

此时Oracle已经对返回的结果集上加了排它的行级锁，全部其余对这些数据进行的修改或删除操做都必须等待这个锁的释放，产生的外在现象就是其它的操做将发生阻塞，这个这个操做commit或rollback.

一样这个查询的事务将会对该表加表级锁，不容许对该表的任何ddl操做，不然将会报出ora-00054错误：:resource busy and acquire with nowait specified.

会话1：

SYS@lhrdb S1> create table t_lock_lhr as select rownum as id,0 as type from dual connect by rownum <=3;

Table created.

SYS@lhrdb S1> select * from t_lock_lhr where id=2 and type =0 for update nowait;

ID TYPE

---------- ----------

2 0

会话2：

SYS@lhrdb S2> select * from t_lock_lhr where id=2 and type=0 for update nowait;

select * from t_lock_lhr where id=2 and type=0 for update nowait

ERROR at line 1:

ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired

会话1：

SYS@lhrdb S1> update t_lock_lhr set type=1 where id=2 and type=0;

1 row updated.

SYS@lhrdb S1> commit;

Commit complete.

SYS@lhrdb S1> select * from t_lock_lhr where id=2;

ID TYPE

---------- ----------

2 1

会话2：

SYS@lhrdb S2> select * from t_lock_lhr where id=2 and type=0 for update nowait;

no rows selected

2.3.2 乐观锁

乐观的认为数据在select出来到update进取并提交的这段时间数据不会被更改。这里面有一种潜在的危险就是因为被选出的结果集并无被锁定，是存在一种可能被其余用户更改的可能。所以Oracle仍然建议是用悲观封锁，由于这样会更安全。

会话1：

SYS@lhrdb S1> select id,type,ora_rowscn from t_lock_lhr where id = 3;

ID TYPE ORA_ROWSCN

---------- ---------- ----------

3 0 37698547

会话2：

SYS@lhrdb S2> select id,type,ora_rowscn from t_lock_lhr where id = 3;

ID TYPE ORA_ROWSCN

---------- ---------- ----------

3 0 37698547

会话1：

SYS@lhrdb S1> update t_lock_lhr set type=1 where ora_rowscn=37698547 and id = 3;

1 row updated.

SYS@lhrdb S1> commit;

Commit complete.

SYS@lhrdb S1> select id,type,ora_rowscn from t_lock_lhr where id = 3;

ID TYPE ORA_ROWSCN

---------- ---------- ----------

3 1 37698591

会话2：

SYS@lhrdb S2> update t_lock_lhr set type=1 where ora_rowscn=37698547 and id =3;

0 rows updated.

SYS@lhrdb S2> select id,type,ora_rowscn from t_lock_lhr where id = 3;

ID TYPE ORA_ROWSCN

---------- ---------- ----------

3 1 37698591

2.3.3 更新丢失问题的解决方法

更新丢失是指多个用户经过应用程序访问数据库时，因为查询数据并返回到页面和用户修改完毕点击保存按钮将修改后的结果保存到数据库这个时间段（即修改数据在页面上停留的时间）在不一样用户之间可能存在误差，从而最早查询数据而且最后提交数据的用户会把其余用户所做的修改覆盖掉。

解决方法以下：

2.4 锁转换和锁升级（Lock Conversion and Escalation）

数据库在必要时执行锁转换。在锁转换中，数据库自动将较低限制的表锁转换为较高限制的其它锁定。一个事务在该事务中全部执行插入、更新、或删除的行上持有行独占锁。由于行锁是在最高程度限制下得到的，所以不要求锁转换，也不执行锁转换。锁转换不一样于锁升级，锁升级发生在当某个粒度级别持有许多锁（例如行），数据库将其提升到更高粒度级别（例如表）。若是一个用户锁定了一个表中的许多行，则某些数据库自动将行锁升级到单个表锁。锁的数量减小了，但被锁定的东西却增长了。

Oracle数据库永远不会升级锁。锁升级极大地增长了死锁的可能性。假定一个系统尝试升级事务1中的锁，但由于事务2持有该锁，故不能成功。若是事务2在它能够继续操做以前也须要在相同的数据上进行锁升级，则将发生一个死锁。

ORACLE的锁是block里面实现的,SQLSERVER,DB2是内存里面实现的.内存实现有资源消耗问题,当内存不足会引起锁升级,可是ORACLE不会发生锁升级。

事务拥有在此事务内被插入（insert），更新（update），删除（delete）的数据行的排它行级锁（exclusive row lock）。对于数据行来讲，排它行级锁已是限制程度最高的锁，所以无需再进行锁转换（lock conversion）。

2.5 锁的分类

Oracle可以自动地选择不一样类型的锁对数据并发访问进行控制，防止用户间破坏性的交互操做。Oracle 将自动地为事务进行锁管理，防止其它事务对须要排它访问的资源执行操做。当事务再也不须要加锁的资源并触发某个事件后，锁可以被自动地释放。

在事务执行期间，Oracle 可以根据加锁的资源及须要执行的操做自动地决定锁的类型（types of lock）及对资源的限制级别（level of restrictiveness）。

V$LOCK_TYPE 该视图是对DML锁的类型的解释。

select * from V$LOCK_TYPE v where v.IS_USER='YES';

当Oracle执行DML语句时，系统自动在所要操做的表上申请TM类型的锁。当TM锁得到后，系统再自动申请TX类型的锁，并将实际锁定的数据行的锁标志位进行置位。这样在事务加锁前检查TX锁相容性时就不用再逐行检查锁标志，而只需检查TM锁模式的相容性便可，大大提升了系统的效率。TM锁包括了SS、SX、S、X等多种模式，在数据库中用0－6来表示。不一样的SQL操做产生不一样类型的TM锁。

在数据行上只有X锁（排它锁）。在Oracle数据库中，当一个事务首次发起一个DML语句时就得到一个TX锁，该锁保持到事务被提交或回滚。当两个或多个会话在表的同一条记录上执行DML语句时，第一个会话在该条记录上加锁，其它的会话处于等待状态。当第一个会话提交后，TX锁被释放，其它会话才能够加锁。

当Oracle数据库发生TX锁等待时，若是不及时处理经常会引发Oracle数据库挂起，或致使死锁的发生，产生ORA-60的错误。这些现象都会对实际应用产生极大的危害，如长时间未响应，大量事务失败等。

2.5.1 DML锁（DML Locks）

当Oracle执行DELETE,UPDATE,INSERT,SELECT FOR UPDATE DML语句时，oracle首先自动在所要操做的表上申请TM类型的锁。当TM锁得到后，再自动申请TX类型的锁，并将实际锁定的数据行的锁标志位(lb 即lock bytes)进行置位。在记录被某一会话锁定后，其它须要访问被锁定对象的会话会按先进先出的方式等待锁的释放，对于select操做而言，并不须要任何锁，因此即便记录被锁定，select语句依然能够执行，实际上，在此状况下，oracle是用到undo的内容进行一致性读来实现的。

当Oracle执行DML语句时，系统自动在所要操做的表上申请TM类型的锁。当TM锁得到后，系统再自动申请TX类型的锁，并将实际锁定的数据行的锁标志位进行置位。这样在事务加锁前检查TX锁相容性时就不用再逐行检查锁标志，而只需检查TM锁模式的相容性便可，大大提升了系统的效率。DML语句可以自动地得到所需的表级锁（table-level lock）与行级锁（row-level lock）。

DML锁，也称为数据锁，确保由多个用户并发访问的数据的完整性。例如，DML锁可防止两个客户从一个在线书店购买某一本书所剩的最后一个拷贝。DML锁也能够防止多个相互冲突的DML或DDL操做产生破坏性干扰。

DML语句自动获取下列类型的锁：

n 行锁(TX)

n 表锁(TM)

2.5.1.1 行锁（Row Locks，TX）

行级锁（row-level lock）的做用是防止两个事务同时修改相同的数据行。当一个事务须要修改一行数据时，就需对此行数据加锁。Oracle 对语句或事务所能得到的行级锁的数量没有限制，Oracle 也不会讲行级锁的粒度升级（lock escalation）。行级锁是粒度最精细的锁，所以行级锁可以提供最好的数据并发访问能力及数据处理能力。

Oracle 同时支持多版本并发访问控制（multiversion concurrency control）及行级锁技术（row-level locking），所以用户只有在访问相同数据行时才会出现竞争，具体来讲：

l 读取操做无需等待对相同数据行的写入操做。

l 写入操做无需等待对相同数据行的读取操做，除非读取操做使用了 SELECT ... FOR UPDATE 语句，此读取语句须要对数据加锁。

l 写入操做只需等待并发地且针对相同数据行的其它写入操做。

提示：读取操做可能会等待对相同数据块（data block）的写入操做，这种状况只会在出现挂起的分布式事务（pending distributed transaction）时偶尔出现。

在执行下列语句时，事务须要得到被修改的每一数据行的排它行级锁（exclusive row lock）：INSERT，UPDATE，DELETE，及使用了FOR UPDATE 子句的 SELECT 语句。

在事务被提交或回滚前，此事务拥有在其内部被修改的全部数据行的排它锁，其它事务不能对这些数据行进行修改操做。可是，若是事务因为实例故障而终止，在整个事务被恢复前，数据块级的恢复将使数据块内数据行上的锁释放。执行前面提到的 4 种 SQL 语句时，Oracle 能自动地对行级锁进行管理。

当事务得到了某些数据行上的行级锁时，此事务同时得到了数据行所属表上的表级锁（table lock）。表级锁可以防止系统中并发地执行有冲突的 DDL 操做，避免当前事务中的数据操做被并发地 DDL 操做影响。

行级锁机制：

当一个事务开始时，必须申请一个TX锁，这种锁保护的资源是回滚段、回滚数据块。所以申请也就意味着：用户进程必须先申请到回滚段资源后才开始一个事务，才能执行DML操做。申请到回滚段后，用户事务就能够修改数据了。具体顺序以下：

一、首先得到TM锁，保护事务执行时，其余用户不能修改表结构

二、事务修改某个数据块中记录时，该数据块头部的ITL表中申请一个空闲表项，在其中记录事务项号，实际就是记录这个事务要使用的回滚段的地址（应该叫包含）

三、事务修改数据块中的某条记录时，会设置记录头部的ITL索引指向上一步申请到的表项。而后修改记录。修改前先在回滚段将记录以前的状态作一个拷贝，而后修改表中数据。

四、其余用户并发修改这条记录时，会根据记录头部ITL索引读取ITL表项内容，确认是否事务提交。

五、若没有提交，必须等待TX锁释放

从上面的机制来看，不管一个事务修改多少条记录，都只须要一个TX锁。所谓的“行级锁”其实也就是数据块头、数据记录头的一些字段，不会消耗额外的资源。从另外一方面也证实了，当用户被阻塞时，不是被某条记录阻塞，而是被TX锁堵塞。也正由于这点，不少人也倾向把TX锁称为事务锁。这里可经过实验来验证所说结论。

会话1：

SQL> select * from test;

ID NAME

---------- --------

1 A

2 B

3 C

SQL> savepoint a;

Savepoint created.

SQL> update test set name='ssss' where id=2;

1 row updated.

会话2，更新同一行发生阻塞：

SQL> update test set name='ssdsdsds'where id=2;

会话1：

SQL> rollback to a;

Rollback complete.

能够看到，虽然会话1已经撤销了对记录的修改，可是会话2仍然处于等待状态这是由于会话2是被会话1的TX锁阻塞的，而不是被会话1上的行级锁阻塞(rollback to savepoint不会结束事务) 。

会话3：

SQL> select username,event,sid,blocking_session from v$session where SID IN (146,159);

USERNAME EVENT SID BLOCKING_SESSION

-------- ----------------------------------- ---------- ----------------

HR enq: TX - row lock contention 146 159

HR SQL*Net message from client 159

会话1：

SQL> rollback;

会话2：

SQL> update test set name='ssdsdsds'where id=2;

1 row updated.

会话3：

SQL> select username,event,sid,blocking_session from v$session where username='HR';

USERNAME EVENT SID BLOCKING_SESSION

-------- ----------------------------------- ---------- ----------------

HR SQL*Net message from client 159

事务结束，tx锁释放，会话2update执行成功。

行锁，也称为TX 锁，是一个表中单个行上的锁。一个事务在被INSERT、UPDATE、DELETE、MERGE、或SELECT ... FOR UPDATE 等语句所修改的每一行上获取一个行锁。行锁一直存在直到事务提交或回滚。行锁主要做为一种排队的机制，以防止两个事务修改相同的行。数据库始终以独占模式锁定修改的行，以便其它事务不能修改该行，直到持有锁的事务提交或回滚。行锁定提供了近乎最细粒度的锁定，并所以提供了近乎最佳的并发性和吞吐量。

若是一个事务由于数据库实例失效而终止，会先进行块级恢复以使行可用，以后进行整个事务恢复。

2.5.1.2 表锁（Table Locks，TM）

表级锁（table-level lock）的做用是对并发的 DDL 操做进行访问控制，例如防止在 DML 语句执行期间相关的表被移除。当用户对表执行 DDL 或 DML 操做时，将获取一个此表的表级锁。表级锁不会影响其余并发的 DML 操做。对于分区表来讲，表级锁既能够针对整个表，也能够只针对某个分区。

当用户执行如下 DML 语句对表进行修改：INSERT，UPDATE，DELETE，及 SELECT ... FOR UPDATE，或执行 LOCK TABLE 语句时，事务将获取一个表级锁。这些 DML 语句获取表级锁的目的有两个：首先保证自身对表的访问不受其它事务 DML 语句的干扰，其次阻止其它事务中和自身有冲突的 DDL 操做执行。任何类型的表级锁都将阻止对此表的排它 DDL 锁（exclusive DDL lock），从而阻止了必须具有排它 DDL 锁才能执行的 DDL 操做。例如，当一个未提交的事务拥有某个表上的锁时，此表就没法被修改定义或被移除。

表级锁具备如下几种模式：行共享（row share，RS），行排它（row exclusive，RX），共享（share，S），共享行排它（share row exclusive，SRX），及排它（exclusive，X）。各类模式的表级锁具备的限制级别决定了其是否能与其余表级锁共处于同一数据表上。

下表显示了各类语句所得到的表级锁的模式，以及此模式下被容许或禁止的操做。

ORACLE里锁有如下几种模式:

锁的兼容模式以下表所示：

表锁，也称为TM锁，当一个表被INSERT、UPDATE、DELETE、MERGE、带FOR UPDATE子句的SELECT等修改时，由相关事务获取该锁。DML操做须要表锁来为事务保护DML对表的访问，并防止可能与事务冲突的DDL操做。

表锁可能如下列模式之一持有：

1、行共享(RS) Row Share (RS)

这种锁也被称为子共享表锁(SS，subshare table lock)，表示在表上持有锁的事务在表中有被锁定的行，并打算更新它们。行共享锁是限制最少的表级锁模式，提供在表上最高程度的并发性。

一、实验

ROW SHARE模式容许同时访问被锁定的表，可是禁止用户以排它方式锁定整个表。ROW SHARE与SHARE UPDATE相同，只是为了兼容早期的Oracle版本。对应lmode2，row-S (SS)。

版本：11.2.0.4

会话1：

SYS@lhrdb> set sqlprompt "_user'@'_connect_identifier S1> "

SYS@lhrdb S1> select userenv('sid') from dual;

USERENV('SID')

--------------

SYS@lhrdb S1> LOCK TABLE SCOTT.EMP IN ROW SHARE MODE;

Table(s) Locked.

会话2：

SYS@lhrdb> set sqlprompt "_user'@'_connect_identifier S2> "

SYS@lhrdb S2> select userenv('sid') from dual;

USERENV('SID')

--------------

114

SYS@lhrdb S2> LOCK TABLE SCOTT.EMP IN EXCLUSIVE MODE;

====>>>>> 产生了阻塞

查询2个会话的锁：

SYS@lhrdb S1> SELECT D.SID, D.TYPE, D.ID1, D.ID2, D.LMODE, D.REQUEST, D.CTIME, D.BLOCK

2 FROM V$LOCK D

3 WHERE D.SID IN (114, 6)

4 ORDER BY D.SID, D.TYPE;

SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------- -- ---------- ---------- ---------- ---------- ---------- ----------

6 AE 100 0 4 0 231 0

6 TM 86893 0 2 0 169 1

114 AE 100 0 4 0 378 0

114 TM 86893 0 0 6 144 0

114 TO 79619 1 3 0 376 0

SELECT D.SID, D.TYPE, D.ID1, D.ID2, D.LMODE, D.REQUEST, D.CTIME, D.BLOCK

FROM V$LOCK D

WHERE D.SID IN (114, 6)

ORDER BY D.SID, D.TYPE;

由BLOCK列能够看到sid为6的会话阻塞了一个会话，这里其实就是114，而114正在请求模式为6的锁。将2个会话提交后继续测试：

SYS@lhrdb S1> LOCK TABLE SCOTT.EMP IN SHARE UPDATE MODE;

Table(s) Locked.

SYS@lhrdb S1> SELECT D.SID, D.TYPE, D.ID1, D.ID2, D.LMODE, D.REQUEST, D.CTIME, D.BLOCK

2 FROM V$LOCK D

3 WHERE D.SID IN (114, 6)

4 AND D.TYPE = 'TM'

5 ORDER BY D.SID, D.TYPE;

SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------- -- ---------- ---------- ---------- ---------- ---------- ----------

6 TM 86893 0 2 0 387 0

2、行独占表锁 Row Exclusive Table Lock (RX)

这种锁也被称为子独占表锁（SX，subexclusive table lock），一般表示持有锁的事务已更新了表行或发出了SELECT...FOR UPDATE。一个SX锁容许其它事务并发地查询、插入、更新、删除、或锁定在同一个表中的其它行。所以，SX锁容许多个事务对同一个表同时得到SX和子共享表锁。

ROW EXCLUSIE相似于ROW SHARE模式，可是不能应用在SHARE模式中。当update,insert,delete发生时，ROW EXCLUSIVE会自动得到。对应lmode3，row-X (SX) 。

一、实验

实验内容：but it also prohibits locking in SHARE mode

会话1：

SQL> set sqlprompt "_user'@'_connect_identifier S1> "

SYS@oratest S1> select distinct sid from v$mystat;

SID

----------

SYS@oratest S1> lock table scott.emp in share mode;

Table(s) Locked.

会话2：

SQL> set sqlprompt "_user'@'_connect_identifier S2> "

SYS@oratest S2> select distinct sid from v$mystat;

SID

----------

142

SYS@oratest S2> lock table scott.emp in row exclusive mode;

====>>>>> 产生了阻塞

查看锁：

SYS@oratest S1> set line 9999

SYS@oratest S1> select * from v$lock where sid in (21,142);

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00000000774D8518 00000000774D8570 142 TO 68064 1 3 0 7021 0

00000000774D9870 00000000774D98C8 142 TO 76985 1 3 0 7365 0

00000000774D9DC8 00000000774D9E20 21 AE 100 0 4 0 162 0

00000000774DA068 00000000774DA0C0 142 AE 100 0 4 0 7379 0

00007F567ADC2700 00007F567ADC2760 142 TM 75335 0 0 3 36 0

00007F567ADC2700 00007F567ADC2760 21 TM 75335 0 4 0 58 1

6 rows selected.

SYS@oratest S1> select * from v$lock where sid in (21,142) AND TYPE IN ('TX','TM');

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00007F567ADC7818 00007F567ADC7878 142 TM 75335 0 0 3 76 0

00007F567ADC7818 00007F567ADC7878 21 TM 75335 0 4 0 98 1

SYS@oratest S1> SELECT * FROM DBA_DML_LOCKS;

SESSION_ID OWNER NAME MODE_HELD MODE_REQUESTE LAST_CONVERT BLOCKING_OTHERS

---------- ------------------------------ ------------------------------ ------------- ------------- ------------ ----------------------------------------

142 SCOTT EMP None Row-X (SX) 101 Not Blocking

21 SCOTT EMP Share None 123 Blocking

SYS@oratest S1>

这里能够看到会话1的TM4阻塞了会话2的TM3。

提交2个会话后，接着实验：ROW EXCLUSIVE locks are automatically obtained when updating, inserting, or deleting.

SYS@oratest S1> update scott.emp set sal=sal where empno=7369;

1 row updated.

SYS@oratest S1> select * from v$lock where sid in (21,142) AND TYPE IN ('TX','TM');

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00007F567ADE6AC8 00007F567ADE6B28 21 TM 75335 0 3 0 4 0

0000000076227AB0 0000000076227B28 21 TX 196620 1097 6 0 4 0

当会话1作了修改而没有commit或者rollback时，这里有两个锁，其中一个就是TM3的，一个是TX6的。

3、共享表锁 Share Table Lock (S)

由某个事务拥有的共享表锁容许其它事务查询（而不使用SELECT...FOR UPDATE)，可是更新操做只能在仅有单个事务持有共享表锁时才容许。由于可能有多个事务同时持有共享表锁，因此持有此锁不足以确保一个事务能够修改该表。

SHARE容许同时查询，可是禁止更新被锁定的表。对应lmode4，share (S) 。

一、实验

会话1：

SQL> set sqlprompt "_user'@'_connect_identifier S1> "

SYS@oratest S1> select distinct sid from v$mystat;

SID

----------

SYS@oratest S1> lock table scott.emp in share mode;

Table(s) Locked.

会话2：

SQL> set sqlprompt "_user'@'_connect_identifier S2> "

SYS@oratest S2> select distinct sid from v$mystat;

SID

----------

142

SYS@oratest S2> update scott.emp set sal=sal where empno=7369;

====>>>>> 产生了阻塞

查看锁：

SYS@oratest S1> select * from v$lock where sid in (21,142) AND TYPE IN ('TX','TM');

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00007F567ADE6AC8 00007F567ADE6B28 142 TM 75335 0 0 3 43 0

00007F567ADE6AC8 00007F567ADE6B28 21 TM 75335 0 4 0 62 1

SYS@oratest S1> SELECT * FROM DBA_DML_LOCKS;

SESSION_ID OWNER NAME MODE_HELD MODE_REQUESTE LAST_CONVERT BLOCKING_OTHERS

---------- -------- ------ ------------- ------------- ------------ ---------------

142 SCOTT EMP None Row-X (SX) 113 Not Blocking

21 SCOTT EMP Share None 132 Blocking

SYS@oratest S1>

这里能够看到会话1的TM4阻塞了会话2的TM3。

4、共享行独占表锁 Share Row Exclusive Table Lock (SRX)

这种锁也称为共享子独占表锁（SSX，share-subexclusive table lock），比共享表锁的限制性更强。一次只能有一个事务能够获取给定的表上的SSX锁。由某个事务拥有的SSX锁容许其它事务查询该表（除SELECT...FOR UPDATE）但不能更新该表。

共享行级排它锁有时也称共享子排它锁（Share Subexclusive Table Lock，SSX），它比共享锁有更多限制。定义共享行级排它锁的语法为：

Lock Table TableName In Share Row Exclusive Mode;

一、实验

会话1：

SQL> set sqlprompt "_user'@'_connect_identifier S1> "

SYS@oratest S1> select distinct sid from v$mystat;

SID

----------

SYS@oratest S1> lock table scott.emp in share row exclusive mode;

Table(s) Locked.

会话2：

SQL> set sqlprompt "_user'@'_connect_identifier S2> "

SYS@oratest S2> select distinct sid from v$mystat;

SID

----------

142

SYS@oratest S2> lock table scott.emp in share mode;

====>>>>> 产生了阻塞

查看锁：

SYS@oratest S1> select * from v$lock where sid in (21,142) AND TYPE IN ('TX','TM');

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00007F567ADE7B00 00007F567ADE7B60 142 TM 75335 0 0 4 21 0

00007F567ADE7B00 00007F567ADE7B60 21 TM 75335 0 5 0 69 1

SYS@oratest S1> SELECT * FROM DBA_DML_LOCKS;

SESSION_ID OWNER NAME MODE_HELD MODE_REQUESTE LAST_CONVERT BLOCKING_OTHERS

---------- ------- ------ ------------- ------------- ------------ ---------------

142 SCOTT EMP None Share 44 Not Blocking

21 SCOTT EMP S/Row-X (SSX) None 92 Blocking

这里能够看到会话1的TM5阻塞了会话2的TM4。

5、独占表锁 Exclusive Table Lock (X)

这种锁是最严格的锁，禁止其它事务执行任何类型的DML语句，或在表上放置任何类型的锁。

EXCLUSIVE EXCLUSIVE permits queries on the locked table but prohibits any other activity on it.

EXCLUSIVE模式容许查询被锁表上的数据，可是禁止任何其余任何活动（这里我理解是禁止添加其余任何模式的锁）。对应lomde6，exclusive (X) 。

一、实验

会话1：

SQL> set sqlprompt "_user'@'_connect_identifier S1> "

SYS@oratest S1> select distinct sid from v$mystat;

SID

----------

SYS@oratest S1> CREATE TABLE SCOTT.EMP_01 AS SELECT * FROM SCOTT.EMP;

Table created.

SYS@oratest S1> update scott.emp_01 set sal=sal where empno=7369;

1 row updated.

会话2：

SQL> set sqlprompt "_user'@'_connect_identifier S2> "

SYS@oratest S2> select distinct sid from v$mystat;

SID

----------

142

SYS@oratest S2> DELETE FROM scott.emp_01 where empno=7369;

====>>>>> 产生了阻塞

查看锁：

SYS@oratest S1> select * from v$lock where sid in (21,142) AND TYPE IN ('TX','TM');

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00000000774D9EA8 00000000774D9F00 142 TX 393247 1337 0 6 28 0

00007F567ABBC0A0 00007F567ABBC100 142 TM 77624 0 3 0 28 0

00007F567ABBC0A0 00007F567ABBC100 21 TM 77624 0 3 0 36 0

0000000076255548 00000000762555C0 21 TX 393247 1337 6 0 36 1

SYS@oratest S1> SELECT * FROM DBA_DML_LOCKS;

SESSION_ID OWNER NAME MODE_HELD MODE_REQUESTE LAST_CONVERT BLOCKING_OTHERS

---------- -------- -------- ------------- ------------- ------------ ---------------

142 SCOTT EMP_01 Row-X (SX) None 35 Not Blocking

21 SCOTT EMP_01 Row-X (SX) None 43 Not Blocking

在这里，从BLOCK字段能够看到会话1的TM3并没堵塞会话2的TM3，这里真正发生堵塞的是会话1的TX6。

这里还有一个锁定对象的问题。上面两个TM3的锁针对的对象是object_id为77624的表，既然描述是相似行共享，天然是不会堵塞的。而两个TX6的锁针对的对象能够理解成表中的行，在这些行上添加EXCLUSIVE锁（lmode6，exclusive (X) )天然是会堵塞其余的EXCLUSIVE锁的。

解决这种类型的锁堵塞固然就是在代码中尽早commit结束事务。不少地方都写到尽早commit能够提升运行效率，这里所指的是释放锁（特别是lmode6的EXCLUSIVE锁）减小堵塞，以提升并发性。（不是以减小数据的量来提升效率的，事实上无论多大的数据量，一个commit的过程都是很"平"的。

二、 **INSERT /+APPEND/ INTO加6级TM和TX独占锁**

会话1：

SYS@lhrdb> set sqlprompt "_user'@'_connect_identifier S1> "

SYS@lhrdb S1> SELECT DISTINCT SID FROM V$MYSTAT;

SID

----------

SYS@lhrdb S1> CREATE TABLE T_APPEND_161107_LHR AS SELECT * FROM DUAL;

Table created.

SYS@lhrdb S1> INSERT /*+ APPEND */ INTO T_APPEND_161107_LHR SELECT * FROM DUAL;

3 rows created.

会话2：

SYS@lhrdb> set sqlprompt "_user'@'_connect_identifier S2> "

SYS@lhrdb S2> SELECT DISTINCT SID FROM V$MYSTAT;

SID

----------

162

SYS@lhrdb S2> INSERT /*+ APPEND */ INTO T_APPEND_161107_LHR SELECT * FROM DUAL;

<<<<<<<<<-------- 产生了阻塞

会话3：

SYS@lhrdb> set sqlprompt "_user'@'_connect_identifier S3> "

SYS@lhrdb S3> set line 9999

SYS@lhrdb S3> SELECT * FROM V$LOCK T WHERE T.SID IN (27,162) AND T.TYPE IN ('TX','TM') ORDER BY T.SID ;

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00000001109F5A40 00000001109F5AA0 27 TM 100957 0 6 0 2217 1

070001007C7EB2B0 070001007C7EB328 27 TX 589843 58249 6 0 2217 0

00000001109F5A40 00000001109F5AA0 162 TM 100957 0 0 6 2214 0

====>>>>> 过了好久

SYS@lhrdb S3> SELECT * FROM V$LOCK T WHERE T.SID IN (27,162) AND T.TYPE IN ('TX','TM') ORDER BY T.SID ;

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00000001109F6A78 00000001109F6AD8 27 TM 100957 0 6 0 2882 1

070001007C7EB2B0 070001007C7EB328 27 TX 589843 58249 6 0 2882 0

00000001109F6A78 00000001109F6AD8 162 TM 100957 0 0 6 2879 0

SYS@lhrdb S3> /

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00000001109F5A40 00000001109F5AA0 27 TM 100957 0 6 0 2885 1

070001007C7EB2B0 070001007C7EB328 27 TX 589843 58249 6 0 2885 0

00000001109F5A40 00000001109F5AA0 162 TM 100957 0 0 6 2882 0

其中，会话1的sid为27，分别在TX和TM级别，拥有LMODE为6的X锁。BLOCK为1说明会话1阻塞了其它会话（0表示没有阻塞，2表示RAC环境须要用GV$LOCK）。CTIME表示拥有此锁的时间，单位为秒。会话2的sid为162，REQUEST为6表示正在请求模式为6的锁。

当TYPE列为TM的时候，即对于TM锁来讲，ID1列表示被锁定的对象的对象ID，ID2始终为0，以下：

SYS@lhrdb S3> COL OWNER FORMAT A5

SYS@lhrdb S3> COL OBJECT_NAME FORMAT A20

SYS@lhrdb S3> SELECT D.OWNER,D.OBJECT_NAME,D.OBJECT_ID FROM DBA_OBJECTS D WHERE D.OBJECT_ID = 100957;

OWNER OBJECT_NAME OBJECT_ID

----- -------------------- ----------

SYS T_APPEND_161107_LHR 100957

当TYPE列为TX的时候，即对于TX锁来讲，ID1列表示事务使用的回滚段编号以及在事务表中对应的记录编号，ID2表示该记录编号被重用的次数（wrap），ID1列表示事务的信息，以下：

SYS@lhrdb S3> SELECT A.TADDR FROM V$SESSION A WHERE SID = 27;

TADDR

----------------

070001007C7EB2B0

SYS@lhrdb S3> SELECT A.XIDUSN, A.XIDSLOT, A.XIDSQN

2 FROM V$TRANSACTION A

3 WHERE A.ADDR = '070001007C7EB2B0';

XIDUSN XIDSLOT XIDSQN

---------- ---------- ----------

9 19 58249

SYS@lhrdb S3> SELECT TRUNC(589843 / POWER(2, 16)) AS UNDO_SEG#,

2 BITAND(589843, TO_NUMBER('ffff', 'xxxx')) + 0 AS SLOT#,

3 58249 XIDSQN

4 FROM DUAL;

UNDO_SEG# SLOT# XIDSQN

---------- ---------- ----------

9 19 58249

SYS@lhrdb S3> SELECT SID,

2 STATUS,

3 SQL_ID,

4 LAST_CALL_ET,

5 BLOCKING_INSTANCE,

6 BLOCKING_SESSION,

7 EVENT

8 FROM GV$SESSION

9 WHERE BLOCKING_SESSION IS NOT NULL;

SID STATUS SQL_ID LAST_CALL_ET BLOCKING_INSTANCE BLOCKING_SESSION EVENT

---------- -------- ------------- ------------ ----------------- ---------------- ---------------------

162 ACTIVE 2kvrfkkjukryr 4875 1 27 enq: TM - contention

SYS@lhrdb S3> select sql_text from v$sql where sql_id='2kvrfkkjukryr';

SQL_TEXT

----------------------------------------------------

INSERT /*+ APPEND */ INTO T_APPEND_161107_LHR SELECT * FROM DUAL

SYS@lhrdb S3> SELECT * FROM DBA_DML_LOCKS D WHERE D.SESSION_ID IN (27, 162);

SESSION_ID OWNER NAME MODE_HELD MODE_REQUESTE LAST_CONVERT BLOCKING_OTHERS

---------- ----- --------------------- ------------- ------------- ------------ ---------------

27 SYS T_APPEND_161107_LHR Exclusive None 647 Blocking

162 SYS T_APPEND_161107_LHR None Exclusive 468 Not Blocking

从视图DBA_DML_LOCKS能够很是直观的看出锁的状况，会话1即SID为27，拥有Exclusive的排它锁，没有请求其它锁，而会话2即SID为162正在请求Exclusive的排它锁。

SELECT * FROM V$EVENT_NAME WHERE NAME = 'enq: TM - contention';

从会话查询锁的信息：

SELECT SID,

STATUS,

SQL_ID,

LAST_CALL_ET,

EVENT,

A.P1,

A.P2,

A.P3,

CHR(BITAND(P1, -16777216) / 16777215) ||

CHR(BITAND(P1, 16711680) / 65535) "LOCK",

BITAND(P1, 65535) "MODE",

(SELECT OBJECT_NAME FROM DBA_OBJECTS D WHERE D.OBJECT_ID = A.P2) OBJECT_NAME

FROM GV$SESSION A

WHERE A.EVENT = 'enq: TM - contention';

会话1提交，查看会话2的状况：

SYS@lhrdb S1> commit;

Commit complete.

SYS@lhrdb S1>

会话2：

SYS@lhrdb S2> INSERT /*+ APPEND */ INTO T_APPEND_161107_LHR SELECT * FROM DUAL;

3 rows created.

SYS@lhrdb S2> SYS@lhrdb S2> SYS@lhrdb S2> commit;

Commit complete.

SYS@lhrdb S2> SELECT * FROM V$LOCK T WHERE T.SID IN (27,162) AND T.TYPE IN ('TX','TM') ORDER BY T.SID ;

no rows selected

二.5.1.3 总结

执行不一样的 DML 语句时，Oracle自动地对数据加锁。

1、查询操做默认获取的锁

执行查询（query）的 SQL 语句不易与其余 SQL 语句冲突，由于查询只需读取数据。除了 SELECT 以外，INSERT，UPDATE，及 DELETE 语句中也可能包含隐式的查询。所以，如下语句都属于查询操做：

SELECT

INSERT ... SELECT ... ;

UPDATE ... ;

DELETE ... ;

可是如下语句不属于查询操做：

SELECT ... FOR UPDATE OF ... ;

查询操做具有如下特性：

l 查询无需获取数据锁。所以当某事务查询数据表时，其它事务能够并发地查询、更新同一个表，包括此表中正在被查询的数据行。没有使用 FOR UPDATE 子句的 SELECT 语句无需获取任何数据锁，所以也不会阻塞任何操做，此类查询在 Oracle 中被称为非阻塞查询（nonblocking query）。

l 执行查询也不受数据锁的限制。（在某些特殊状况下，查询须要等待挂起的分布式事务所拥有的数据锁）

2、 INSERT，UPDATE，DELETE，及 SELECT ... FOR UPDATE 语句默认获取的锁

INSERT，UPDATE，DELETE，及 SELECT ... FOR UPDATE 语句默认获取的锁有如下特色：

l 包含 DML 语句的事务须要得到被其修改的数据行上的排它行级锁（exclusive row lock）。在拥有锁的事务提交或回滚前，其它事务不能更新或删除被加锁的数据行。

l 事务无需获取 DML 语句内的子查询（subquery）或隐式查询（implicit query）（例如 WHERE 子句内的查询）所选择的行上的行级锁。DML 内的子查询或隐式查询得到的数据相对查询开始的时间点知足一致性，这些查询不会看到 DML 语句自身对数据的影响。

l 事务内的查询可以看到本事务内以前执行的 DML 语句对数据的修改，但没法看到本事务开始后执行的其它事务对数据的修改。

l 事务内的 DML 语句除了须要得到必要的排它行级锁（exclusive row lock）外，至少还需得到包含被修改数据行的表上的行排它表级锁（row exclusive table lock）。若是事务已经得到了相关表上的共享表级锁（share），共享行排它表级锁（share row exclusive），或排它表级锁（exclusive），那么就无需获取行排它表级锁了。若是事务已经得到了相关表上的行共享表级锁（row share table lock），Oracle 将自动地将此锁转换为行排它表级锁。

2.5.2 DDL锁（DDL Locks）

当某个运行中的DDL操做正在操做或引用某模式对象时，数据字典(DDL)锁保护该模式对象的定义。在DDL操做的过程当中，只有被修改或引用的单个模式的对象被锁定。数据库毫不会锁定整个数据字典。

Oracle数据库将为任何要求锁的DDL事务自动获取DDL锁。用户不能显式请求DDL锁。例如，若是用户建立一个存储过程，则数据库自动为过程定义中引用的全部模式对象获取DDL锁。DDL锁防止在过程编译完成以前，这些对象被更改或删除。

数据字典锁（data dictionary lock，DDL）的做用是在执行 DDL 操做时对被修改的方案对象或其引用对象的定义进行保护。管理员及开发者应该意识到 DDL 语句将会隐式地提交一个事务。例如，用户建立一个存储过程时，至关于执行一个只包含一条 SQL 语句的事务，Oracle 会自动获取过程定义中所引用的全部方案对象的 DDL 锁。DDL 锁可以防止编译期间过程所引用的对象被其它事务修改或移除。

当 DDL 事务须要时 Oracle 将自动地为其获取数据字典锁。用户不能显示地获取 DDL 锁。只有在 DDL 操做中被修改或引用的对象才会被加锁，整个数据字典不会被加锁。

当用户发布DDL（Data Definition Language）语句时会对涉及的对象加DDL锁。因为DDL语句会更改数据字典，因此该锁也被称为字典锁。

DDL锁能防止在用DML语句操做数据库表时，对表进行删除，或对表的结构进行更改。

对于DDL锁，要注意的是：

l DDL锁只锁定DDL操做所涉及的对象，而不会锁定数据字典中的全部对象。

l DDL锁由Oracle自动加锁和释放。不能显式地给对象加DDL锁，即没有加DDL锁的语句。

l 在过程当中引用的对象，在过程编译结束以前不能被改变或删除，即不能被加排它DDL锁。

DDL 锁能够分为三类：排它 Ddl 锁（Exclusive DDL Lock），共享 Ddl 锁（Share DDL Lock），及可中断的解析锁（Breakable Parse Lock）。

2.5.2.1 排它DDL锁（eXclusive DDL Locks，XDDL）--独占DDL锁

大多数DDL 都带有一个排它DDL 锁。若是发出以下一条语句：

Alter table t add new_column date;

在执行这条语句时，表T 不能被别人修改。在此期间，可使用SELECT 查询这个表，可是大多数其余操做都不容许执行，包括全部DDL 语句。

独占DDL锁可防止其它会话获取DDL或DML锁。除了那些在"共享DDL锁"中所述操做以外，绝大多数DDL操做须要对资源获取独占锁，以防止和其它可能会修改或引用相同模式对象的DDL之间的破坏性干扰。例如，当ALTER TABLE正在将一列添加到表时，不容许DROP TABLE删除表，反之亦然。

独占DDL锁在整个DDL语句执行期间一直持续，并自动提交。在独占DDL锁获取过程当中，若是另外一个操做在该模式对象上持有另外一个DDL锁，则这个锁获取将一直等待，直到前一个DDL锁被释放，才能继续。

2.5.2.2 共享DDL锁（Share DDL Locks，SDDL）

create index t_idx on t(x) ONLINE;

ONLINE 关键字会改变具体创建索引的方法。Oracle 并非加一个排它DDL 锁防止数据修改，而只会试图获得表上的一个低级（mode 2 ）TM 锁。这会有效地防止其余DDL 发生，同时还容许DML 正常进行。Oracle 执行这一壮举”的作法是，为DDL 语句执行期间对表所作的修改维护一个记录，执行CREATE 时再把这些修改应用至新的索引。这样能大大增长数据的可用性。

另一类DDL 会得到共享DDL 锁。在建立存储的编译对象（如过程和视图）时，会对依赖的对象加这种共享DDL 锁。例如，若是执行如下语句：

Create view MyView as select * from emp, dept where emp.deptno = dept.deptno;

表EMP 和DEPT 上都会加共享DDL 锁，而CREATE VIEW 命令仍在处理。能够修改这些表的内容，可是不能修改它们的结构。

A share DDL lock for a resource prevents destructive interference with conflicting DDL operations, but allows data concurrency for similar DDL operations.

在资源上的共享DDL锁可防止与冲突的DDL操做发生破坏性干扰，但容许相似的DDL操做的数据并发。

例如，当CREATE PROCEDURE语句运行时，所在事务将为全部被引用的表获取共享DDL锁。其它事务能够同时建立引用相同表的过程，并在相同的表上同时得到共享DDL锁，但没有任何事务能在任何被引用表上获取独占DDL锁。

共享DDL锁在整个DDL语句执行期间持续存在，并自动提交。所以，持有一个共享DDL锁的事务，可保证在事务过程当中，被引用模式对象的定义保持不变。

某些 DDL 操做须要获取相关资源上的共享 DDL 锁（share DDL lock）以防止与之冲突的 DDL 操做形成破坏性的干扰，但与之相似的 DDL 操做能够并发地访问数据，不受共享 DDL 锁的限制。例如，执行 CREATE PROCEDURE 语句时，事务将获取全部引用对象上的共享 DDL 锁。此时，其它事务能够并发地获取相同表上的共享 DDL 锁并建立引用了相同表的过程。但任何事务都没法获取被引用表上的排它 DDL 锁（exclusive DDL lock），即任何事务都没法对表进行修改或移除操做。所以得到了共享 DDL 锁的事务可以保证在其执行期间，全部引用对象的定义不会被修改。

执行如下 DDL 语句时，须要获取引用对象上的共享 DDL 锁：AUDIT，NOAUDIT，COMMENT，CREATE [OR REPLACE] VIEW/ PROCEDURE/PACKAGE/PACKAGE BODY/FUNCTION/ TRIGGER，CREATE SYNONYM，及 CREATE TABLE（没有使用 CLUSTER 参数时）。

2.5.2.3 分析锁（Breakable Parse Locks，可中断解析锁，BPL）

SQL语句或PL/SQL程序单元，为每一个被其引用的模式对象持有一个解析锁。获取解析锁的目的是，若是被引用的对象被更改或删除，可使相关联的共享SQL区无效。解析锁被称为可中断的解析锁，由于它并不由止任何DDL操做，并能够被打破以容许冲突的DDL操做。

解析锁是在执行SQL语句的分析阶段，在共享池中获取的。只要该语句的共享SQL区仍保留在共享池中，该锁就一直被持有。

位于共享池（shared pool）内的 SQL 语句（或 PL/SQL 程序结构）拥有其引用的全部方案对象上的解析锁（parse lock）。解析锁的做用是，当共享 SQL 区（shared SQL area）所引用的对象被修改或移除后，此共享 SQL 区可以被置为无效。解析锁不会禁止任何 DDL 操做，当出现与解析锁冲突的 DDL 操做时，解析锁将被解除，所以也称之为可解除的解析锁。

解析锁是在 SQL 语句执行的解析阶段（parse phase）得到的，在共享 SQL 区被清除出共享池（shared pool）前一直保持。

你的会话解析一条语句时，对于该语句引用的每个对象都会加一个解析锁。加这些锁的目的是：若是以某种方式删除或修改了一个被引用的对象，能够将共享池中已解析的缓存语句置为无效（刷新输出）。

1、查看分析锁

CREATE OR REPLACE PROCEDURE P_BPL_LHR AS

BEGIN

NULL;

END;

要看到一个实际的可中断解析锁，下面先建立并运行存储过程P_BPL_LHR：

SYS@lhrdb> CREATE OR REPLACE PROCEDURE P_BPL_LHR AS

2 BEGIN

3 NULL;

4 END;

5 /

Procedure created.

SYS@lhrdb> exec P_BPL_LHR;

PL/SQL procedure successfully completed.

SYS@lhrdb> SELECT DISTINCT SID FROM V$MYSTAT;

SID

----------

194

过程P_BPL_LHR如今会出如今DBA_DDL_LOCKS 视图中。咱们有这个过程的一个解析锁：

SELECT * FROM DBA_DDL_LOCKS D WHERE D.SESSION_ID = 194;

而后从新编译这个过程，并再次查询视图：

SYS@lhrdb> ALTER PROCEDURE P_BPL_LHR COMPILE;

Procedure altered.

能够看到，如今这个视图中没有P_BPL_LHR了。咱们的解析锁被中断了。这个视图对发人员颇有用，发现测试或开发系统中某段代码没法编译时，将会挂起并最终超时。这说明，有人正在使用这段代码（实际上在运行这段代码），你可使用这个视图查看这我的是谁。对于GRANTS 和对象的其余类型的DDL 也是同样。例如，没法对正在运行的过程授予EXECUTE 权限。可使用一样的方法发现潜在的阻塞者和等待者。

2.5.2.4 DDL 锁的持续时间

DDL 锁的持续时间取决于其类型。共享 DDL 锁（share DDL lock）及排它 DDL 锁（exclusive DDL lock）在 DDL 语句执行期间一直存在，在 DDL 语句自动提交后释放。而解析锁一直存在，直至相关的共享 SQL 区从共享池中被清除。

2.5.2.5 DDL 锁与簇

对簇（cluster）执行的 DDL 操做须要获取簇及簇内全部表及物化视图上的排它 DDL 锁（exclusive DDL lock）。对簇内表及物化视图的 DDL 操做须要获取簇上的共享 DDL 锁（share DDL lock），以及表或物化视图上的共享 DDL 锁或排它 DDL 锁。簇上的共享 DDL 锁可以防止操做期间其余 DDL 操做将簇移除。

2.5.3 系统锁（System Locks）

Oracle数据库使用各类类型的系统锁，来保护数据库内部和内存结构。因为用户不能控制其什么时候发生或持续多久，这些机制对于用户几乎是不可访问的。闩锁、互斥体、和内部锁是彻底自动的。

2.5.3.1 闩锁（Latches）

闩锁（latche）是一种简单的底层串行化机制，用于保护 SGA 内的共享数据结构。例如，用于记录当前正在访问数据库的用户的列表，或用于记录位于数据库缓存（buffer cache）内的数据块的数据结构，均可经过闩锁进行保护。当服务进程（background process）或后台进程（server process）须要操做或查询此类数据结构时，就须要获取一个闩锁，但其加锁时间极短。闩锁的实现与操做系统有关，例如进程是否须要等待栓锁以及等待多长时间等。

闩锁是简单、低级别的串行化机制，用于协调对共享数据结构、对象、和文件的多用户访问。闩锁防止共享内存资源被多个进程访问时遭到破坏。具体而言，闩锁在如下状况下保护数据结构：

l 被多个会话同时修改

l 正在被一个会话读取时，又被另外一个会话修改

l 正在被访问时，其内存被释放（换出）

一般，一个单一的闩锁保护SGA中的多个对象。例如，后台进程（如DBWn和LGWR）从共享池分配内存来建立数据结构。为分配此内存，这些进程使用共享池闩锁来串行化对内存的访问，以防止两个进程同时尝试检查或修改共享池。内存分配后，其它进程可能须要访问共享池区域，如用于解析所需的库高速缓存。在这种状况下，进程只在库缓存获取闩锁，而不是在整个共享池。

与行锁之类的入队闩锁不一样，闩锁不容许会话排队。当闩锁可用时，请求闩锁的第一个会话将得到它的独占访问权限。闩锁旋转（Latch spinning）发生在当一个进程不断地循环来请求一个闩锁时，而闩锁睡眠（latch sleeping）发生在从新发起闩锁请求以前，释放CPU时。

一般，一个Oracle进程在操做或查看一种数据结构时，只需在一个极短的时间内得到闩锁。例如，仅仅为某一名员工处理工资更新，数据库就可能须要获取并释放成千上万个闩锁。闩锁的实现依赖于操做系统，特别是在一个进程是否会在闩锁上等待以及会在闩锁等待多长时间方面。

闩锁的增长意味着并发的下降。例如，过分硬解析操做会产生库缓存闩锁争用。V$LATCH视图包含每一个闩锁的详细使用状况的统计信息，包括每一个闩锁被请求和被等待的次数。

2.5.3.2 互斥对象（Mutexes）

互斥对象（mutual exclusion object，mutex），也叫互斥体，它是一种底层机制，用于防止在内存中的对象在被多个并发进程访问时，被换出内存或遭到破坏。互斥对象相似于闩锁，但闩锁一般保护一组对象，而互斥对象一般保护单个对象。

互斥对象提供如下几个优势：

一、互斥体能够减小发生争用的可能性。

因为闩锁保护多个对象，当多个进程试图同时访问这些对象的任何一个时，它可能成为一个瓶颈。而互斥体仅仅串行化对单个对象的访问，而不是一组对象，所以互斥体提升了可用性。

二、互斥体比闩锁消耗更少的内存。

三、在共享模式下，互斥体容许被多个会话并发引用。

2.5.3.3 内部锁（Internal Locks）

内部锁是比闩锁和互斥体更高级、更复杂的机制，并用于各类目的。数据库使用如下类型的内部锁：

一、字典缓存锁（Dictionary cache locks）

这些锁的持续时间很短，当字典缓存中的条目正在被修改或使用时被持有。它们保证正在被解析的语句不会看到不一致的对象定义。字典缓存锁能够是共享的或独占的。共享锁在解析完成后被释放，而独占锁在DDL操做完成时释放。

当用户更新或使用时数据字典缓存内的条目（entry）时，须要获取条目上的数据字典缓存锁（dictionary cache lock），此类锁的持续时间极短。此类锁的做用是确保正在被解析的语句不会看到不一致的对象定义。数据字典缓存锁能够为共享或排它的。当语句解析结束时共享锁将被释放，而当 DDL 操做结束时排它锁将被释放。

二、文件和日志管理锁（File and log management locks）

这些锁保护各类文件。例如，一种内部锁保护控制文件，以便一次只有一个进程能够对其进行更改。而另外一种锁用于协调联机重作日志文件的使用和归档。数据文件被锁定，确保数据库被多个实例以共享模式装载，或以独占模式被单个实例装载。由于文件和日志锁表示文件的状态，这些锁必要时会被持有较长一段时间。

此类内部锁（internal lock）用于保护各类文件。例如，保护控制文件（control file）的锁，确保同一时间只有一个进程可以对其进行修改。还有协调重作日志文件（redo log file）使用与归档的锁。以及数据文件（datafile）锁，实现多实例在共享模式下挂载数据库，或一个实例在排它模式下挂载数据库。因为文件及重作日志锁反映的是物理文件的状态，所以此类锁的持续时间较长。

三、表空间和撤销段锁（Tablespace and undo segment locks）

这些锁保护的表空间和撤销段。例如，访问数据库的全部实例对一个表空间是否处于联机或脱机必须保持一致。撤销段被锁定，以便只能有一个数据库实例能够写入该段。

此类锁用于保护表空间及回滚段（rollback segment）。例如，一个表空间处于联机（online）仍是脱机（offline）状态对访问同一数据库的全部实例应该是一致的。回滚段上的锁保证同一时间只有一个实例可以对其执行写操做。

2.6 死锁(Deadlock)

有关死锁的内容以前发布过一次，具体内容参考：http://blog.itpub.net/26736162/viewspace-2127247/，本篇文章再也不讲解。

2.7 数据字典

经常使用的数据字典视图有DBA_DML_LOCKS、DBA_DDL_LOCKS、V$LOCK、DBA_LOCK、V$LOCKED_OBJECT。

---查询的都是当前实例的锁

select * from dba_dml_locks;

select * from dba_ddl_locks d where d.owner not in('SYS','WMSYS','MDSYS');

select * from DBA_LOCK V where V.session_id=23;

select * from V$LOCK V where V.SID=23;

select * from V$LOCK_TYPE;

select * from V$LOCKED_OBJECT;

2.7.1 V$LOCK和dba_lock、dba_locks

本视图列出Oracle 服务器当前拥有的锁以及未完成的锁或栓锁请求。

2.7.1.1 三者关系

v$lock和dba_locks和 dba_lock 内容同样，dba_locks是dba_lock的同义词。能够用动态性能视图的定义来查看它们的关系V$FIXED_VIEW_DEFINITION。

SELECT * FROM Dba_Objects d WHERE d.object_name LIKE '%DBA_LOCK%' ;

SELECT * FROM Dba_Synonyms d WHERE d.synonym_name LIKE '%DBA_LOCK%' ;

SELECT * FROM V$FIXED_VIEW_DEFINITION d WHERE d.VIEW_NAME LIKE '%V$LOCK%' ;

2.7.2 V$LOCKED_OBJECT

注意：V$LOCKED_OBJECT记录的是DML锁信息，DDL锁的信息不在里面。

这个视图列出系统上的每一个事务处理所得到的全部锁。记录了当前已经被锁定的对象的信息

XIDUSN表示当前事务使用的回滚段的编号

XIDSLOT说明该事务在回滚段头部的事务表中对应的记录编号

XIDSQN说明序列号

OBJECT_ID说明当前被锁定的对象的ID号，能够根据该ID号到dba_objects里查找被锁定的对象名称

LOCKED_MODE说明锁定模式的数字编码

V$LOCKED_OBJECT中的列说明：

示例：1.以DBA角色查看当前数据库里锁的状况能够用以下SQL语句：

SELECT v.object_id,

d.OBJECT_NAME,

d.OBJECT_TYPE,

locked_mode,

v2.username,

v2.sid,

v2.serial#,

v2.logon_time

FROM v$locked_object v,

dba_objects d,

v$session v2

WHERE v.OBJECT_ID = d.OBJECT_ID

AND v.SESSION_ID = v2.SID

ORDER BY v2.logon_time;

v$locked_object视图列出当前系统中哪些对象正被锁定.

v$lock视图列出当前系统持有的或正在申请的全部锁的状况.

2.7.3 DBA_DDL_LOCKS

DBA_DDL_LOCKS lists all DDL locks held in the database and all outstanding requests for a DDL lock.

查询全部DDL锁的信息：

SELECT * FROM DBA_DDL_LOCKS D WHERE D.SESSION_ID = 115;

若是提示没有这个视图，能够在sys用户下执行$ORACLE_HOME/rdbms/admin/catblock.sql脚本进行建立（这个脚本还包含其余一些很是有意义的锁相关视图）

sys@ora10g> conn / as sysdba

Connected.

sys@ora10g> @?/rdbms/admin/catblock.sql

这里省略建立过程

打印一下catblock.sql脚本的内容，这个建立脚本其实能够当作一个参考文档来用，尤为是其中关于锁类型的描述。

2.7.4 DBA_DML_LOCKS

DBA_DML_LOCKS lists all DML locks held in the database and all outstanding requests for a DML lock.

SQL> CREATE TABLE TB_DML_LOCK_LHR (ID NUMBER);

Table created.

SQL> INSERT INTO TB_DML_LOCK_LHR VALUES(1);

1 row created.

SQL> set line 9999

SQL> SELECT * FROM DBA_DML_LOCKS;

SESSION_ID OWNER NAME MODE_HELD MODE_REQUESTE LAST_CONVERT BLOCKING_OTHERS

---------- ------- ------------------ ------------- ------------- ------------ -----------------

151 SYS TB_DML_LOCK_LHR Row-X (SX) None 10 Not Blocking

SQL>

2.7.5 一些字段的说明

会话1：

SYS@oratest S1> select distinct sid from v$mystat;

SID

----------

SYS@oratest S1> CREATE TABLE SCOTT.EMP_LHR AS SELECT * FROM SCOTT.EMP;

Table created.

SYS@oratest S1> delete from scott.EMP_LHR where empno=7369;

1 row deleted.

SYS@oratest S1>

会话2：

SYS@oratest S2> select distinct sid from v$mystat;

SID

----------

143

SYS@oratest S2> delete from scott.EMP_LHR where empno=7369;

====>>>>> 产生了阻塞

会话3查询锁：

SQL> set line 9999

SQL> SELECT A.TADDR,

2 A.LOCKWAIT,

3 A.ROW_WAIT_OBJ#,

4 A.ROW_WAIT_FILE#,

5 A.ROW_WAIT_BLOCK#,

6 A.ROW_WAIT_ROW#,

7 A.EVENT,

8 A.P1,

9 A.P2,

10 A.SID,

11 A.BLOCKING_SESSION

12 FROM V$SESSION A

13 WHERE A.SID IN (22, 143);

TADDR LOCKWAIT ROW_WAIT_OBJ# ROW_WAIT_FILE# ROW_WAIT_BLOCK# ROW_WAIT_ROW# EVENT P1 P2 SID BLOCKING_SESSION

---------------- ---------------- ------------- -------------- --------------- ------------- ------------------------------ ---------- ---------- ---------- ----------------

000000007622B710 -1 0 0 0 SQL*Net message from client 1650815232 1 22

000000007622AD00 00000000774DA0C0 77669 8 2799 0 enq: TX - row lock contention 1415053318 524299 143 22

V$SESSION视图的TADDR列表示事务处理状态对象的地址，对应于V$TRANSACTION.ADDR列；V$SESSION视图的LOCKWAIT列表示等待锁的地址，对应于V$LOCK的KADDR列；若当前会话没有被阻塞则为空。V$SESSION视图的SADDR列对应于V$TRANSACTION的SES_ADDR列。能够经过ROW_WAIT_OBJ#、ROW_WAIT_FILE#、ROW_WAIT_BLOCK#、ROW_WAIT_ROW#这几个字段查询如今正在被锁的表的相关信息（ROWID），例如，表名、文件名及行号。P1和P2根据等待事件的不一样所表明的含义不一样，能够从V$EVENT_NAME视图获知每一个参数的含义。

SQL> SELECT D.PARAMETER1,D.PARAMETER2,D.PARAMETER3 FROM V$EVENT_NAME D WHERE D.NAME='enq: TX - row lock contention';

PARAMETER1 PARAMETER2 PARAMETER3

------------ --------------- ----------

name|mode usn<<16 | slot sequence

SQL> SELECT CHR(BITAND(P1, -16777216) / 16777215) ||

2 CHR(BITAND(P1, 16711680) / 65535) "LOCK",

3 BITAND(P1, 65535) "MODE",

4 TRUNC(P2 / POWER(2, 16)) AS XIDUSN,

5 BITAND(P2, TO_NUMBER('FFFF', 'XXXX')) + 0 AS XIDSLOT,

6 P3 XIDSQN

7 FROM V$SESSION A

8 WHERE A.SID IN (143);

LOCK MODE XIDUSN XIDSLOT XIDSQN

---- ---------- ---------- ---------- ----------

TX 6 4 30 894

<<<<<---从P1参数获知请求的锁的类型和模式；从P2参数能够获知槽位号

SQL> SELECT ADDR,XIDUSN,XIDSLOT,XIDSQN FROM v$transaction a WHERE a.ADDR IN ('000000007622B710');

ADDR XIDUSN XIDSLOT XIDSQN

---------------- ---------- ---------- ----------

000000007622B710 4 30 894

SQL> SELECT ADDR,XIDUSN,XIDSLOT,XIDSQN FROM v$transaction a WHERE a.SES_ADDR ='0000000077E6F600';

ADDR XIDUSN XIDSLOT XIDSQN

---------------- ---------- ---------- ----------

000000007622B710 4 30 894

SQL> SELECT * FROM V$LOCK A WHERE A.SID IN (22, 143) AND A.TYPE IN ('TX','TM') AND A.KADDR='00000000774DA0C0' ORDER BY a.SID,a.TYPE;

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00000000774DA068 00000000774DA0C0 143 TX 262174 894 0 6 658 0

SQL> SELECT DBMS_ROWID.ROWID_CREATE(1, 77766, 4, 131, 0) FROM DUAL;

DBMS_ROWID.ROWID_C

------------------

AAAS/GAAEAAAACDAAA

SQL> SELECT * FROM SCOTT.EMP A WHERE A.ROWID='AAAS/GAAEAAAACDAAA';

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

---------- ---------- --------- ---------- ------------------- ---------- ---------- ----------

7369 SMITH CLERK 7902 1980-12-17 00:00:00 800 20

SQL>

能够看到被锁的行的地址。

SQL> SELECT * FROM V$LOCK A WHERE A.SID IN (22, 143) AND A.TYPE IN ('TX','TM') ORDER BY a.SID,a.TYPE;

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00007FF44BF72D18 00007FF44BF72D78 22 TM 77766 0 3 0 793 0

000000007622B710 000000007622B788 22 TX 262174 894 6 0 793 1

00007FF44BF72D18 00007FF44BF72D78 143 TM 77766 0 3 0 787 0

00000000774DA068 00000000774DA0C0 143 TX 262174 894 0 6 787 0

6 rows selected.

SQL>

SQL> SELECT * FROM DBA_DML_LOCKS D WHERE D.SESSION_ID IN (22, 143) ORDER BY d.SESSION_ID;

SESSION_ID OWNER NAME MODE_HELD MODE_REQUESTE LAST_CONVERT BLOCKING_OTHERS

---------- -------- -------- ------------- ------------- ------------ ---------------

22 SCOTT EMP_LHR Row-X (SX) None 1146 Not Blocking

143 SCOTT EMP_LHR Row-X (SX) None 1140 Not Blocking

SQL> SELECT D.OWNER, D.OBJECT_NAME, D.OBJECT_ID, D.OBJECT_TYPE

2 FROM DBA_OBJECTS D

3 WHERE D.OBJECT_ID IN (77766);

OWNER OBJECT_NAME OBJECT_ID OBJECT_TYPE

-------- ------------ ---------- -------------------

SCOTT EMP_LHR 77766 TABLE

SQL> SQL> SELECT a.XIDUSN,

2 a.XIDSLOT,

3 a.XIDSQN FROM v$transaction a WHERE a.XIDSQN =894;

XIDUSN XIDSLOT XIDSQN

---------- ---------- ----------

4 30 894

SQL> SELECT 4*POWER(2,16)+30 FROM DUAL;

4*POWER(2,16)+30

----------------

262174

SQL>

SQL> SELECT TRUNC(ID1 / POWER(2, 16)) AS XIDUSN,

2 BITAND(ID1, TO_NUMBER('FFFF', 'XXXX')) + 0 AS XIDSLOT,

3 894 XIDSQN

4 FROM V$LOCK A

5 WHERE A.SID IN (22, 143)

6 AND A.TYPE IN ('TX', 'TM')

7 AND A.ADDR = '000000007622B710'

8 ORDER BY A.SID, A.TYPE;

XIDUSN XIDSLOT XIDSQN

---------- ---------- ----------

4 30 894

在V$LOCK中，当TYPE列的值为TM时，ID1的值为DBA_OBJECTS.OBJECT_ID；当为TX锁时，ID1对应视图V$TRANSACTION中的XIDUSN字段（Undo segment number：事务对应的撤销段序列号）和XIDSLOT字段（Slot number：事务对应的槽位号）。其中ID1的高16位为XIDUSN，低16位为XIDSLOT。计算公式为：SELECT TRUNC(ID1/POWER(2,16)) AS XIDUSN,BITAND(ID1,TO_NUMBER('FFFF','XXXX')) + 0 AS XIDSLOT , ID2 XIDSQN FROM DUAL;

在V$LOCK中，当TYPE列的值为TM锁时，ID2的值为0；当为TX锁时，ID2对应视图V$TRANSACTION中的XIDSQN字段（Sequence number：事务对应的序列号）。

从V$SESSION视图能够获得全部内容：

SELECT A.TADDR,

A.LOCKWAIT,

A.ROW_WAIT_OBJ#,

A.ROW_WAIT_FILE#,

A.ROW_WAIT_BLOCK#,

A.ROW_WAIT_ROW#,

(SELECT D.OWNER || '|' || D.OBJECT_NAME || '|' || D.OBJECT_TYPE

FROM DBA_OBJECTS D

WHERE D.OBJECT_ID = A.ROW_WAIT_OBJ#) OBJECT_NAME,

A.EVENT,

A.P1,

A.P2,

A.P3,

CHR(BITAND(P1, -16777216) / 16777215) ||

CHR(BITAND(P1, 16711680) / 65535) "LOCK",

BITAND(P1, 65535) "MODE",

TRUNC(P2 / POWER(2, 16)) AS XIDUSN,

BITAND(P2, TO_NUMBER('FFFF', 'XXXX')) + 0 AS XIDSLOT,

P3 XIDSQN,

A.SID,

A.BLOCKING_SESSION,

A.SADDR,

DBMS_ROWID.ROWID_CREATE(1, 77669, 8, 2799, 0) REQUEST_ROWID,

(SELECT B.SQL_TEXT

FROM V$SQL B

WHERE B.SQL_ID = NVL(A.SQL_ID, A.PREV_SQL_ID)) SQL_TEXT

FROM V$SESSION A

WHERE A.SID IN (143);

2.7.5.1 关联关系图

2.8 参数

2.8.1 DML_LOCKS参数

能够得到的TX锁定的总个数由初始化参数transactions决定，而能够得到的TM锁定的个数则由初始化参数dml_locks决定

select name,value from v$parameter where name in('transactions','dml_locks');

SYS@racdb1> col name format a15

SYS@racdb1> col value format a5

SYS@racdb1> select name,value from v$parameter where name in('transactions','dml_locks');

NAME VALUE

--------------- -----

dml_locks 1088

transactions 272

SYS@racdb1> select 272*4 from dual;

272*4

----------

1088

DML_LOCKS参数属于推导参数，DML_LOCKS=4 * TRANSACTIONS。

select resource_name as "R_N",current_utilization as "C_U",max_utilization as "M_U",initial_allocation as "I_U"

from v$resource_limit

where resource_name in('transactions','dml_locks');

SYS@racdb1> select resource_name as "R_N",current_utilization as "C_U",max_utilization as "M_U",initial_allocation as "I_U"

2 from v$resource_limit

3 where resource_name in('transactions','dml_locks');

R_N C_U M_U I_U

------------------------------ ---------- ---------- --------------------

dml_locks 0 28 1088

transactions 0 6 272

系统中容许的TM 锁总数能够由你配置（有关细节请见Oracle Database Reference 手册中的DML_LOCKS 参数定义）。实际上，这个数可能设置为0。但这并非说你的数据库变成了一个只读数据库（没有锁），而是说不容许DDL。在很是专业的应用（如RAC 实现）中，这一点就颇有用，能够减小实例内可能发生的协调次数。经过使用ALTER TABLE TABLENAME DISABLE TABLE LOCK 命令，还能够逐对象地禁用TM 锁。这是一种快捷方法，可使意外删除表的难度更大”，由于在删除表以前，你必须从新启用表锁。还能用它检测因为外键未加索引而致使的全表锁（前面已经讨论过）。

Property	Description
Parameter type	Integer
Default value	Derived: 4 * TRANSACTIONS
Modifiable	No
Range of values	20 to unlimited; a setting of 0 disables enqueues
Basic	No
Oracle RAC	You must set this parameter for every instance, and all instances must have positive values or all must be 0.

A DML lock is a lock obtained on a table that is undergoing a DML operation (insert, update, delete). DML_LOCKS specifies the maximum number of DML locks—one for each table modified in a transaction. The value should equal the grand total of locks on tables currently referenced by all users. For example, if three users are modifying data in one table, then three entries would be required. If three users are modifying data in two tables, then six entries would be required.

The default value assumes an average of four tables referenced for each transaction. For some systems, this value may not be enough.

Enqueues are shared memory structures that serialize access to database resources. If you set the value of DML_LOCKS to 0, enqueues are disabled and performance is slightly increased. However, you should be aware of the following restrictions when you set you DML_LOCKS to 0:

l You cannot use DROP TABLE, CREATE INDEX statements

l You cannot use explicit lock statements such as LOCK TABLE IN EXCLUSIVE MODE

l Enterprise Manager cannot run on any instances for which DML_LOCKS is set to 0

Oracle holds more locks during parallel DML than during serial execution. Therefore, if your database supports a lot of parallel DML, you may need to increase the value of this parameter.

2.8.2 DDL_LOCK_TIMEOUT

11g之前，DDL 语句是不会等待DML语句的，当DDL语句访问的对象正在执行的DML语句，会当即报错ORA-00054: 资源正忙, 但指定以 NOWAIT 方式获取资源, 或者超时失效。而在11g之后，DDL_LOCK_TIMEOUT参数能够修改这一状态，当DDL_LOCK_TIMEOUT=0时，DDL 不等待DML，当DDL_LOCK_TIMEOUT 为N（秒）时，DDL等待DML N 秒，该值默认为0。

Property	Description
Parameter type	Integer
Default value	0
Modifiable	ALTER SESSION
Range of values	0 to 1,000,000 (in seconds)
Basic	No

DDL_LOCK_TIMEOUT specifies a time limit for how long DDL statements will wait in a DML lock queue. The default value of zero indicates a status of NOWAIT. The maximum value of 1,000,000 seconds will result in the DDL statement waiting forever to acquire a DML lock.

If a lock is not acquired before the timeout period expires, then an error is returned.

会话1：

Connected to:

Oracle Database 11g Enterprise Edition Release 11.2.0.3.0 - 64bit Production

With the Partitioning, OLAP, Data Mining and Real Application Testing options

SQL> set sqlprompt "_user'@'_connect_identifier S1> "

SYS@oratest S1> set timing on

SYS@oratest S1> update scott.emp set ename='' where empno=7499;

1 row updated.

Elapsed: 00:00:00.00

SYS@oratest S1>

会话2：

SQL> set sqlprompt "_user'@'_connect_identifier S2> "

SYS@oratest S2> set timing on

SYS@oratest S2> drop table scott.emp;

drop table scott.emp

ERROR at line 1:

ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired

Elapsed: 00:00:00.74

SYS@oratest S2> show parameter ddl_lock_timeout

NAME TYPE VALUE

------------------------------------ ----------- ------------------------------

ddl_lock_timeout integer 0

SYS@oratest S2> alter session set ddl_lock_timeout=5;

Session altered.

Elapsed: 00:00:00.00

SYS@oratest S2> drop table scott.emp;

drop table scott.emp

ERROR at line 1:

ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired

Elapsed: 00:00:05.01

SYS@oratest S2> alter session set ddl_lock_timeout=10;

Session altered.

Elapsed: 00:00:00.00

SYS@oratest S2> drop table scott.emp;

drop table scott.emp

ERROR at line 1:

ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired

Elapsed: 00:00:10.03

SYS@oratest S2>

综上，设置ddl_lock_timeout为N（秒）后，DDL执行后将等待N秒钟后才抛出报错信息。在ddl_lock_timeout为默认值 0 时，DDL语句提交以后立刻报错。

2.9 for update、for update of、for update nowait

SELECT...FOR UPDATE 语句的语法以下：

SELECT ... FOR UPDATE [OF column_list][WAIT n|NOWAIT][SKIP LOCKED];

其中：

l OF 这个OF子句在牵连到多个表时，具备较大做用，如不使用OF指定锁定的表的列，则全部表的相关行均被锁定，若在OF中指定了需修改的列，则只有与这些列相关的表的行才会被锁定。

l WAIT 子句指定等待其余用户释放锁的秒数，防止无限期的等待。

“使用FOR UPDATE WAIT”子句的优势以下：

１防止无限期地等待被锁定的行；

２容许应用程序中对锁的等待时间进行更多的控制。

３对于交互式应用程序很是有用，由于这些用户不能等待不肯定

４若使用了skip locked，则能够越过锁定的行，不会报告由wait n 引起的‘资源忙’异常报告

2.9.1 FOR UPDATE 和 FOR UPDATE NOWAIT 的区别

for update nowait和 for update都会对所查询到得结果集进行加锁，所不一样的是，若是另一个进程正在修改结果集中的数据，for update nowait不会进行资源等待，只要发现结果集中有些数据被加锁，马上返回“ORA-00054错误，内容是资源正忙, 但指定以 NOWAIT 方式获取资源”。

for update 和 for update nowait加上的是一个行级锁，也就是只有符合where条件的数据被加锁。若是仅仅用update语句来更改数据时，可能会由于加不上锁而没有响应地、莫名其妙地等待，但若是在此以前，for update NOWAIT语句将要更改的数据试探性地加锁，就能够经过当即返回的错误提示而明白其中的道理，或许这就是For Update和NOWAIT的意义之所在。

会话1：

SYS@oratest S1> SELECT EMPNO, ENAME FROM SCOTT.EMP WHERE EMPNO = '7369' FOR UPDATE NOWAIT;

EMPNO ENAME

---------- ----------

7369 SMITH

会话2：

SYS@oratest S2> SELECT EMPNO, ENAME FROM SCOTT.EMP WHERE EMPNO = '7369' FOR UPDATE NOWAIT;

SELECT EMPNO, ENAME FROM SCOTT.EMP WHERE EMPNO = '7369' FOR UPDATE NOWAIT

ERROR at line 1:

ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired

上面会话都提交commit，开启会话1，不使用NOWAIT：

SYS@oratest S1> SELECT EMPNO, ENAME FROM SCOTT.EMP WHERE EMPNO = '7369' FOR UPDATE ;

EMPNO ENAME

---------- ----------

7369 SMITH

SYS@oratest S1>

开启另外一会话

SYS@oratest S2> SELECT EMPNO, ENAME FROM SCOTT.EMP WHERE EMPNO = '7369' FOR UPDATE ;

====>>>>> 产生了阻塞

阻塞，不返回错误。提交第一个会话，第二个回话自动执行，而后提交第二个会话

二.9.2 SELECT...FOR UPDATE OF COLUMNS

select for update of，这个of子句在牵连到多个表时，具备较大做用，如不使用of指定锁定的表的列，则全部表的相关行均被锁定，若在of中指定了需修改的列，则只有与这些列相关的表的行才会被锁定。

会话1：

SYS@oratest S1> SELECT * FROM SCOTT.EMP E, SCOTT.DEPT D WHERE E.DEPTNO = D.DEPTNO FOR UPDATE;

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO DEPTNO DNAME LOC

---------- ---------- --------- ---------- ------------------- ---------- ---------- ---------- ---------- -------------- -------------

7369 SMITH CLERK 7902 1980-12-17 00:00:00 800 20 20 RESEARCH DALLAS

7499 ALLEN SALESMAN 7698 1981-02-20 00:00:00 1600 300 30 30 SALES CHICAGO

7521 WARD SALESMAN 7698 1981-02-22 00:00:00 1250 500 30 30 SALES CHICAGO

7566 JONES MANAGER 7839 1981-04-02 00:00:00 2975 20 20 RESEARCH DALLAS

7654 MARTIN SALESMAN 7698 1981-09-28 00:00:00 1250 1400 30 30 SALES CHICAGO

7698 BLAKE MANAGER 7839 1981-05-01 00:00:00 2850 30 30 SALES CHICAGO

7782 CLARK MANAGER 7839 1981-06-09 00:00:00 2450 10 10 ACCOUNTING NEW YORK

7788 SCOTT ANALYST 7566 1987-04-19 00:00:00 3000 20 20 RESEARCH DALLAS

7839 KING PRESIDENT 1981-11-17 00:00:00 5000 10 10 ACCOUNTING NEW YORK

7844 TURNER SALESMAN 7698 1981-09-08 00:00:00 1500 0 30 30 SALES CHICAGO

7876 ADAMS CLERK 7788 1987-05-23 00:00:00 1100 20 20 RESEARCH DALLAS

7900 JAMES CLERK 7698 1981-12-03 00:00:00 950 30 30 SALES CHICAGO

7902 FORD ANALYST 7566 1981-12-03 00:00:00 3000 20 20 RESEARCH DALLAS

7934 MILLER CLERK 7782 1982-01-23 00:00:00 1300 10 10 ACCOUNTING NEW YORK

14 rows selected.

会话2：

SYS@oratest S2> SELECT * FROM SCOTT.DEPT FOR UPDATE NOWAIT;

SELECT * FROM SCOTT.DEPT FOR UPDATE NOWAIT

ERROR at line 1:

ORA-00054: resource busy and acquire with NOWAIT specified or timeout expired

SYS@oratest S2>

SYS@oratest S2> SELECT * FROM V$LOCK A WHERE A.SID IN (16,27) AND A.TYPE IN ('TX','TM') ORDER BY a.SID,a.TYPE;

ADDR KADDR SID TY ID1 ID2 LMODE REQUEST CTIME BLOCK

---------------- ---------------- ---------- -- ---------- ---------- ---------- ---------- ---------- ----------

00007F8FABF13398 00007F8FABF133F8 16 TM 77667 0 3 0 201 0

00007F8FABF13398 00007F8FABF133F8 16 TM 77669 0 3 0 201 0

000000007620A7C0 000000007620A838 16 TX 327687 1138 6 0 201 0

SYS@oratest S2> SELECT * FROM DBA_DML_LOCKS D WHERE D.SESSION_ID IN (16,27) ORDER BY d.SESSION_ID;

SESSION_ID OWNER NAME MODE_HELD MODE_REQUESTE LAST_CONVERT BLOCKING_OTHERS

---------- --------- ------ ------------- ------------- ------------ ---------------

16 SCOTT EMP Row-X (SX) None 225 Not Blocking

16 SCOTT DEPT Row-X (SX) None 225 Not Blocking

SYS@oratest S2>

能够看到，会话1在SCOTT.EMP和SCOTT.DEPT表上都加上了3级的行级排它锁。

提交以上的会话，而后继续试验OF特性：

会话1：

SYS@oratest S1> SELECT * FROM SCOTT.EMP E, SCOTT.DEPT D WHERE E.DEPTNO = D.DEPTNO FOR UPDATE OF SAL ;