|
|
1. Buffer busy waits：
从本质上讲，这个等待事件的产生仅说明了一个会话在等待一个Buffer（数据块），但是导致这个现象的原因却有很多种。常见的两种是：
当一个会话视图修改一个数据块，但这个数据块正在被另一个会话修改时。
当一个会话需要读取一个数据块，但这个数据块正在被另一个会话读取到内存中时。
微观上（latch）看：当你对这个数据块做修改（不是宏观上的行级锁的概念）的短暂时间内，其他的会话将被阻止对这个数据块上的数据做修改（即使其他用户修改的不是当前用户修改的数据），但是可以以一致性的方式读取这个数据块（from undo）。当前的用户修改完这个数据块后，将会立即释放掉加在这个数据块上的排他锁，这样另一个会话就可以继续修改它。 修改操作是一个非常短暂的时间，这种加锁的机制我们叫 Latch。
当一个会话修改一个数据块时，是按照以下步骤来完成的：
（1）以排他的方式获得这个数据块（Latch） （2）修改这个数据块。（3）释放 Latch。
Buffer busy waits 等待事件常见于数据库中存在的热块的时候，当多个用户频繁地读取或者修改同样的数据块时，这个等待事件就会产生。 如果等待的时间很长，我们在AWR或者statspack报告中就可以看到。
这个等待事件有三个参数。 查看有几个参数我们可以用以下SQL:
SQL> select name, parameter1, parameter2, parameter3 from v$event_name where name='buffer busy waits';
NAME PARAMETER1 PARAMETER2 PARAMETER3
-------------------- ---------- ---------- ----------
buffer busy waits file# block# class#
File#: 等待访问数据块所在的文件id号。
Blocks：等待访问的数据块号。
ID： 在10g之前，这个值表示一个等待时间的原因，10g 之后则表示等待事件的类别。
2. Buffer latch：
内存中数据块的存放位置是记录在一个hash列表（cache buffer chains）当中的。当一个会话需要访问某个数据块时，它首先要搜索这个hash列表，从列表中获得数据块的地址，然后通过这个地址去访问需要的数据块，这个列表Oracle会使用一个latch来保护它的完整性。当一个会话需要访问这个列表时，需要获取一个Latch，只有这样，才能保证这个列表在这个会话的浏览当中不会发生变化。产生buffer latch的等待事件的主要原因是：
（1）Buffer chains太长，导致会话搜索这个列表花费的时间太长，使其他的会话处于等待状态。
（2）同样的数据块被频繁访问，就是我们通常说的热块问题。
产生 buffer chains 太长，我们可以使用多个buffer pool（比如keep pool，nk pool）的方式来创建更多的buffer chains，或者使用参数 DB_BLOCK_LRU_LATCHES 来增加 latch 的数量，以便于更多的会话可以获得 latch，这两种方法可以同时使用。
这个等待事件有两个参数：
Latch addr： 会话申请的latch在SGA中的虚拟地址，通过以下的SQL语句可以根据这个地址找到它对应的Latch 名称：
select * from v$latch a,v$latchname b where addr=latch addr -- 这里的latch addr是你从等待事件中看到的值
and a.latch#=b.latch#;
chain#：buffer chains hash列表中的索引值，当这个参数的值等于s 0xfffffff时，说明当前的会话正在等待一个 LRU latch。
3. Control file parallel write
当数据库中有多个控制文件的拷贝时，Oracle需要保证信息同步地写到各个控制文件当中，这是一个并行的物理操作过程。当发生这样的操作时，就会产生control file parallel write等待事件。
控制文件频繁写入的原因很多，比如：
（1）日志切换太过频繁，导致控制文件信息相应地需要频繁更新。
（2）系统I/O出现瓶颈，导致所有I/O出现等待。
当系统出现日志切换过于频繁的情形时，可以考虑适当地增大日志文件的大小来降低日志切换频率。
当系统出现大量的control file parallel write等待事件时，可以通过比如降低控制文件的拷贝数量，将控制文件的拷贝存放在不同的物理磁盘上的方式来缓解I/O 争用。
这个等待事件包含三个参数：
Files： Oracle要写入的控制文件个数。
Blocks：写入控制文件的数据块数目。
Requests：写入控制请求的I/O次数。
4. Control file sequential read
当数据库需要读取控制文件上的信息时，会出现这个等待事件。因为控制文件的信息是顺序写的，所以读取的时候也是顺序的，因此称为控制文件顺序读，
它经常发生在以下情况：
（1）备份控制文件
（2）RAC 环境下不同实例之间控制文件的信息共享
（3）读取控制文件的文件头信息
（4）读取控制文件其他信息
这个等待事件有三个参数：
File#：要读取信息的控制文件的文件号。
Block#：读取控制文件信息的起始数据块号。
Blocks：需要读取的控制文件数据块数目。
5. Db file parallel read
这是一个很容易引起误导的等待事件，实际上这个等待事件和并行操作（比如并行查询，并行 DML）没有关系。 这个事件发生在数据库恢复的时候，当有一些数据块需要恢复的时候，Oracle 会以并行的方式把他们从数据文件中读入到内存中进行恢复操作。
这个等待事件包含三个参数：
Files： 操作需要读取的文件个数。
Blocks： 操作需要读取的数据块个数。
Requests：操作需要执行的I/O次数。
6. Db file parallel write
这是一个后台等待事件，它同样和用户的并行操作没有关系，它是由后台进程DBWR产生的，当后台进程DBWR想磁盘上写入脏数据时，会发生这个等待。DBWR 会批量地将脏数据并行地写入到磁盘上相应的数据文件中，在这个批次作业完成之前，DBWR 将出现这个等待事件。 如果仅仅是这一个等待事件，对用户的操作并没有太大的影响，当伴随着出现 free buffer waits 等待事件时，说明此时内存中可用的空间不足，这时候会影响到用户的操作。比如影响到用户将数据块读入到内存中。当出现db file parallel write 等待事件时，可以通过启用操作系统的异步 I/O的方式来缓解这个等待。当使用异步I/O时，DBWR不在需要一直等到所有数据块全部写入到磁盘上，它只需要等到这个数据写入到一个百分比之后，就可以继续进行后续的操作。
这个等待事件有两个参数：
Requests：操作需要执行的 I/O 次数。
Timeouts：等待的超时时间。
7. Db file scattered read
这个等待事件在实际生产库中经常可以看到，这是一个用户操作引起的等待事件。当用户发出每次 I/O需要读取多个数据块这样的SQL操作时，会产生这个等待事件。最常见的两种情况是全表扫描（FTS：Full Table Scan）和索引块速扫描（IFFS： index fast full scan）。
这个名称中的 scattered( 发散)，可能会导致很多人认为它是以scattered的方式来读取数据块的，其实恰恰相反，当发生这种等待事件时，SQL 的操作都是顺序地读取数据块的，比如FTS或者IFFS方式（如果忽略需要读取的数据块已经存在内存中的情况）。这里的scattered指的是读取的数据块在内存中的存放方式，他们被读取到内存中后，是以分散的方式存在在内存中，而不是连续的。
这个等待事件有三个参数：
File#： 要读取的数据块所在数据文件的文件号。
Block#： 要读取的起始数据块号。
Blocks：需要读取的数据块数目。
8. Db file sequential read
这个等待事件在实际生产库也很常见，当Oracle需要每次I/O只读取单个数据块这样的操作时，会产生这个等待事件。最常见的情况有索引的访问（除IFFS外的方式）、回滚操作、以ROWID的方式访问表中的数据，重建控制文件，对文件头做DUMP等。这里的sequential也并非指的是Oracle按顺序的方式来访问数据，和db file scattered read一样，它指的是读取的数据块在内存中是以连续的方式存放的。这个等待事件有三个参数：
File#：要读取的数据块锁在数据文件的文件号。
Block#：要读取的起始数据块号。
Blocks：要读取的数据块数目（这里应该等于 1）。
9. Db file single write
这个等待事件通常只发生在一种情况下，就是Oracle更新数据文件头信息时（比如发生 Checkpoint）。当这个等待事件很明显时，需要考虑是不是数据库中的数据文件数量太大，导致Oracle需要花较长的时间来做所有文件头的更新操作（checkpoint）。
这个等待事件有三个参数：
File#: 需要更新的数据块所在的数据文件的文件号。
Block#：需要更新的数据块号。
Blocks：需要更新的数据块数目（通常来说应该等于 1）。
10. Direct path read
这个等待事件发生在会话将数据块直接读取到PGA当中而不是SGA中的情况，这些被读取的数据通常是这个会话私有的数据，所以不需要放到SGA作为共享数据。 这些数据通常是来自与临时段上的数据，比如一个会话中SQL 的排序数据、并行执行过程中间产生的数据以及 Hash Join、merge join产生的排序数据，因为这些数据只对当前的会话的SQL操作有意义，所以不需要放到 SGA 当中。当发生direct path read等待事件时，意味着磁盘上有大量的临时数据产生，比如排序、并行执行等操作。 或者意味着PGA中空闲空间不足。
这个等待事件有三个参数：
Descriptor address: 一个指针，指向当前会话正在等待的一个 direct read I/O。
First dba:descriptor address 中最旧的一个 I/O 数据块地址。
Block cnt: descriptor address 上下文中涉及的有效的 buffer 数量。
11. Direct path write
这个等待事件和direct path read正好相反，是会话将一些数据从PGA中直接写入到磁盘文件上，而不经过SGA。这种情况通常发生在：
（1）使用临时表空间排序（内存不足）
（2）数据的直接加载（使用 append 方式加载数据）
（3）并行DML操作。
这个等待事件有三个参数：
Descriptor address: 一个指针，指向当前会话正在等待的一个direct I/O。
First dba: descriptor address中最旧的一个 I/O 数据块地址。
Block cnt: descriptor address上下文中涉及的有效地 buffer 数量。
12. Enqueue
Enqueue这个词其实是lock的另一种描述语。当我们在AWR报告中发现长时间的enqueue等待事件时，说明数据库中出现了阻塞和等待，可以关联AWR报告中的enqueue activity部分来确定是哪一种
锁定出现了长时间等待。这个等待事件有2个参数：
Name：enqueue的名称和类型。
Mode：enqueue的模式。
可以使用如下SQL查看当前会话等待的enqueue名称和类型：
SELECT CHR(TO_CHAR (BITAND (p1, -16777216)) / 16777215)||CHR(TO_CHAR (BITAND (p1, 16711680)) / 65535) "Lock",
TO_CHAR (BITAND (p1, 65535)) "Mode"
FROM v$session_wait
WHERE event = 'enqueue';
Oracle的enqueue包含以下模式：
| 模式代码 | 解释 | | 1 | Null mode | | 2 | Sub-Share | | 3 | Sub-Exclusive | | 4 | Share | | 5 | Share/Sub-Exclusive | | 6 | Exclusive |
Oracle的enqueue有如下类型：
| Enqueue缩写 | 缩写解释 | | BL | Buffer Cach management | | BR | Backup/Restore | CF
| Controlfile transaction | | CI | Cross-instance Call Invocation | | CU | Bind Enqueue | | DF | Datafile | | DL | Direct Loader Index Creation | | DM | Database Mount
| DR
| Distributed Recovery Process
| | DX | Dirstributed Transaction | | FP | File Object | | FS | File Set | | HW | High-water Lock | | IN | Instance Number | | IR | Instance Recovery | | IS | Instance State | | IV | Library Cache Invalidation | | JI | Enqueue used during AJV snapshot refresh | | JQ | Job Queue |
| KK | Redo Log ―Kick‖ | | KO | Multiple Object Checkpoint | | L[A-p] | Library Cache Lock | | LS | Log start or switch | | MM | Mount Definition | | MR | Media recovery | | N[A-Z] | Library Cache bin | | PE | Alter system set parameter =value | | PF | Password file | | PI | Parallel slaves | | PR | Process startup | | PS | Parallel slave synchronization | | Q[A-Z] | Row Cache | | RO | Object Reuse | | RT | Redo Thread | | RW | Row Wait | | SC | System Commit Number | | SM | SMON | | SN | Sequence Number | | SQ | Sequence Number Enqueue | | SR | Synchronized replication | | SS | Sort segment | | ST | Space management transaction | | SV | Sequence number Value | | TA | Transaction recovery | | TC | Thread Checkpoint |
| TE | Extend Table | | TM | DML enqueue | | TO | Temporary Table Object Enqueue | | TS | Temporary Segement(also TableSpace) | | TT | Temporary Table | | TX | Transaction | | UL | User-defined Locks | | UN | User name | | US | Undo segment, Serialization | | WL | Being Written Redo Log | | XA | Instance Attribute Log | | XI | Instance Registration Lock |
13. Free buffer waits
当一个会话将数据块从磁盘读到内存中时，它需要到内存中找到空闲的内存空间来存放这些数据块。当内存中没有空闲的空间时，就会产生这个等待；除此之外，还有一种情况就是会话在做一致性读时，需要构造数据块在某个时刻的前映像（image），此时需要申请内存来存放这些新构造的数据块。如果内存中无法找到这样的内存块，也会发生这个等待事件。
当数据库中出现比较严重的free buffer waits等待事件时，可能的原因是：
（1）data buffer太小，导致空闲空间不够
（2）内存中的脏数据太多，DBWR无法及时将这些脏数据写到磁盘中以释放空间
这个等待事件包含 2 个参数：
File#：需要读取的数据块所在的数据文件的文件号。
Block#：需要读取的数据块块号。
14. Latch free
在10g之前的版本里，latch free等待事件代表了所有的latch等待。在10g以后，一些常用的latch事件已经被独立了出来：
SQL> select name from v$event_name where name like 'latch%' order by 1;
NAME
----------------------------------------------------------------
latch activity
latch free
latch: Change Notification Hash table latch
latch: In memory undo latch
latch: MQL Tracking Latch
latch: PX hash array latch
latch: Undo Hint Latch
latch: WCR: processes HT
latch: WCR: sync
latch: cache buffer handles
latch: cache buffers chains
latch: cache buffers lru chain
latch: call allocation
latch: change notification client cache latch
latch: checkpoint queue latch
latch: enqueue hash chains
latch: gc element
latch: gcs resource hash
latch: ges resource hash list
latch: lob segment dispenser latch
latch: lob segment hash table latch
latch: lob segment query latch
latch: messages
latch: object queue header operation
latch: parallel query alloc buffer
latch: redo allocation
latch: redo copy
latch: redo writing
latch: row cache objects
latch: session allocation
latch: shared pool
latch: undo global data
latch: virtual circuit queues
已选择 33 行。
所以latch free等待事件在10g以后的版本中并不常见，而是以具体的Latch等待事件出现。
这个等待事件有三个参数：
Address: 会话等待的 latch 地址。
Number： latch 号，通过这个号，可以从 v$latchname视图中找到这个latch的相关的信息。
SQL> select * from v$latchname where latch#=number;
Tries: 会话尝试获取 Latch 的次数。
15. Library cache lock
这个等待时间发生在不同用户在共享中由于并发操作同一个数据库对象导致的资源争用的时候。比如当一个用户正在对一个表做DDL操作时，其他的用户如果要访问这张表，就会发生library cache lock等待事件，它要一直等到DDL操作完成后，才能继续操作。
这个事件包含四个参数：
Handle address: 被加载的对象的地址。
Lock address： 锁的地址。
Mode： 被加载对象的数据片段。
Namespace： 被加载对象在 v$db_object_cache 视图中 namespace 名称。
16. Library cache pin
这个等待事件和library cache lock一样是发生在共享池中并发操作引起的事件。通常来讲，如果Oracle要对一些PL/SQL或者视图这样的对象做重新编译，需要将这些对象pin到共享池中。 如果此时这个对象被其他的用户特有，就会产生一个library cache pin的等待。
这个等待事件也包含四个参数：
Handle address: 被加载的对象的地址。
Lock address：锁的地址。
Mode：被加载对象的数据片段。
Namespace： 被加载对象在v$db_object_cache视图中namespace名称。
17. Log file parallel write
后台进程LGWR负责将log buffer当中的数据写到REDO文件中，以重用log buffer的数据。如果每个REDO LOG组里面有2个以上的成员，那么 LGWR进程会并行地将REDO信息写入这些文件中。如果数据库中出现这个等待事件的瓶颈，主要的原因可能是磁盘I/O性能不够或者REDO文件的分布导致了I/O争用，比如同一个组的REDO成员文件放在相同的磁盘上。
这个等待事件有三个参数：
Files：操作需要写入的文件个数。
Blocks：操作需要写入的数据块个数。
Requests：操作需要执行的 I/O 次数。
18. Log buffer space
当log buffer中没有可用空间来存放新产生的redo log数据时，就会发生log buffer space等待事件。 如果数据库中新产生的redo log的数量大于LGWR写入到磁盘中的redo log数量，必须等待LGWR完成写入磁盘的操作，LGWR必须确保redo log写到磁盘成功之后，才能在redo buffer当中重用这部分信息。如果数据库中出现大量的log buffer space 等待事件，可以考虑如下方法：
（1） 增加redo buffer的大小。
（2） 提升磁盘的I/O性能。
19. Log file sequential read
这个等待事件通常发生在对redo log信息进行读取时，比如在线redo的归档操作，ARCH进程需要读取redo log的信息，由于redo log的信息是顺序写入的，所以在读取时也是按照顺序的方式来读取的。
这个等待事件包含三个参数：
Log#：发生等待时读取的redo log的sequence号。
Block#：读取的数据块号。
Blocks：读取的数据块个数。
20. Log file single write
这个等待事件发生在更新redo log文件的文件头时，当为日志组增加新的日志成员时或者redo log的sequence号改变时，LGWR都会更新redo log文件头信息。
这个等待事件包含三个参数：
Log#： 写入的 redo log 组的编号。
Block#：写入的数据块号。
Blocks：写入的数据块个数。
21. Log file switch(archiving needed)
在归档模式下，这个等待事件发生在在线日志切换（log file switch）时，需要切换的在线日志还没有被归档进程（ARCH）归档完毕的时候。 当在线日志文件切换到下一个日志时，需要确保下一个日志文件已经被归档进程归档完毕，否则不允许覆盖那个在线日志信息（否则会导致归档日志信息不完整）。出现这样的等待事件通常是由于某种原因导致ARCH进程死掉，比如ARCH进程尝试向目的地写入一个归档文件，但是没有成功（介质失效或者其他原因），这时ARCH进程就会死掉。 如果发生这种情况，在数据库的alert log文件中可
以找到相关的错误信息。
这个等待事件没有参数。
22. Log file switch(checkpoint incomplete)
当一个在线日志切换到下一个在线日志时，必须发生日志切换的checkpoint。在 v$log 视图里记录了在线日志的状态。 通常来说，在线日志有三种状态：
Active: 这个日志上面保护的信息还没有完全写到数据文件上。
Inactive： 这个日志上面保护的信息已完全写到数据文件上。
Current： 当前的日志。
Oracle 在做实例恢复时，会使用状态为current和Active的日志进行实例恢复。
如果系统中出现大量的log file switch（checkpoint incomplete）等待事件，原因可能是日志文件太小或者日志组太少，所以解决的方法是，增加日志文件的大小或者增加日志组的数量。
这个等待事件没有参数。
23. Log file sync
这是一个用户会话行为导致的等待事件，当一个会话发出一个commit 命令时，LGWR 进程会将这个事务产生的redo log从log buffer里面写到磁盘上，以确保用户提交的信息被安全地记录到数据库中。会话发出的commit指令后，需要等待LGWR将这个事务产生的redo成功写入到磁盘之后，才可以继续进行后续的操作，这个等待事件就叫作log file sync。当系统中出现大量的log file sync等待事件时，应该检查数据库中是否有用户在做频繁的提交操作。这种等待事件通常发生在 OLTP 系统上。 OLTP 系统中存在很多小的事务，
如果这些事务频繁被提交，可能引起大量的 log file sync 的等待事件。
这个等待事件包含一个参数：
Buffer#: redo buffer中需要被写入到磁盘中的 buffer。
24. SQL*Net break/reset to client
当出现这个等待事件时，说明服务器端在给客户端发送一个断开连接或者重置连接的请求，正在等待客户的响应，通常的原因是服务器到客户端的网络不稳定导致的。
这个等待事件包含两个参数：
Driver id: 服务器和客户端连接使用的协议信息。
Break？：零表示服务端向客户端发送一个重置（reset）信息，非零表示服务器端向客户端发送一个断开（break）消息。
25. SQL*Net break/reset to dblink
这个等待事件和SQL*Net break/reset to client 相同。不过它表示的是数据库通过dblink访问另一台数据库时，他们之间建立起一个会话，这个等待事件发生在这个会话之间的通信过程中，同样如果出现这个等待事件，需要检查两台数据库之间的通信问题。
这个等待事件有两个参数：
Driver id: 服务器和客户端连接使用的协议信息。
Break？：零表示服务端向客户端发送一个重置（reset）信息，非零表示服务器端向客户端发送一个断开（break）消息。
26. SQL*Net message from client
这个等待事件基本上是最常见的一个等待事件。当一个会话建立成功后，客户端会向服务器端发送请求，服务器端处理完客户端请求后，将结果返回给客户端，并继续等待客户端的请求，这时候会产生 SQL*Net message from client等待事件。很显然，这是一个空闲等待，如果客户端不再向服务器端发送请求，服务器端将一直处于这个等待事件状态。
这个等待事件包含两个参数：
Driver id: 服务器端和客户端连接使用的协议信息。
#bytes: 服务器端接收到的来自客户端消息的字节数。
27. SQL*Net message from dblink
这个等待事件和SQL*Net message from client相同，不过它表示的是数据库通过dblink访问另一个数据库时，他们之间会建立一个会话。这个等待事件发生在这个会话之间的通信过程中。这个等待事件也是一个空闲等待事件。
这个事件包含两个参数：
Driver id: 服务器端和客户端连接使用的协议信息。
#bytes: 服务器端通过dblink收到的来自另一个服务器端消息的字节数。
28. SQL*Net message to client
这个等待事件发生在服务器端向客户端发送消息的时候。当服务器端向客户端发送消息产生等待时，可能的原因是用户端太繁忙，无法及时接收服务器端送来的消息，也可能是网络问题导致消息无法从服务器端发送到客户端。
这个等待事件有两个参数：
Driver id: 服务器端和客户端连接使用的协议信息。
#bytes: 服务器端向客户端发送消息的字节数。
29. SQL*Net message to dblink
这个等待事件和SQL*Net message to client相同，不过是发生在数据库服务器和服务器之间的等待事件，产生这个等待的原因可能是远程服务器繁忙，而无法及时接收发送过来的消息，也可能是服务器之间网络问题导致消息无法发送过来。
这个等待时间包含两个参数：
Driver id: 服务器端和客户端连接使用的协议信息。
#bytes: 服务器端通过 dblink 发送给另一个服务器消息的字节数。
30. SQL*Net more data from client
服务器端等待用户发出更多的数据以便完成操作，比如一个大的SQL文本，导致一个SQL*Net数据包无法完成传输，这样服务器端会等待客户端把整个SQL文本发过来在做处理，这时候就会产生一个SQL*Net more data from client等待事件。
这个等待时间包含两个参数：
Driver id: 服务器端和客户端连接使用的协议信息。
#bytes: 服务器端从客户端接收到消息的字节数。
31. SQL*Net more data from dblink
在一个分布式事务中，SQL分布在不同的数据库中执行，远程数据库执行完毕后将结果通过dblink返给发出SQL的数据库，在等待数据从其他数据库中通过dblink传回的过程中，如果数据在远程数据库上处理时间很久，或者有大量的结果集需要返回，或者网络性能问题都会产生SQL*Net more data from dblink等待事件，它的意思是本地数据库需要等到所有的数据从远程处理完毕通过dblink传回后，才可以在本机继续执行操作。
这个等待时间包含两个参数：
Driver id: 服务器端和客户端连接使用的协议信息。
#bytes: 服务器端通过 dblink 发送给另一个服务器消息的字节数。
32. SQL*Net more data to client
当服务器端有太多的数据需要发给客户端时，可能会产生SQL*Net more data to client等待事件，也可能由于网络问题导致服务器无法及时地将信息或者处理结果发送给客户端，同样会产生这个等待。
这个等待时间包含两个参数：
Driver id: 服务器端和客户端连接使用的协议信息。
#bytes: 服务器端向客户端发送消息的字节数。
33. SQL*Net more data to dblink
这个等待事件和SQL*Net more data to client等待时间基本相同，只不过等待发生在分布式事务中，即本地数据库需要将更多的数据通过dblink发送给远程数据库。由于发送的数据太多或者网络性能问题，就会出现SQL*Net more data to dblink 等待事件。
这个等待时间包含两个参数：
Driver id: 服务器端和客户端连接使用的协议信息。
#bytes: 服务器端通过 dblink 发送给另一个服务器消息的字节数。
|
|
发表于 2022-6-1 22:15:08
