oracle常见的等待事件说明

转自 http://blog.itpub.net/29371470/viewspace-1063994/ 

 

1. Buffer busy waits

从本质上讲，这个等待事件的产生仅说明了一个会话在等待一个Buffer（数据块），但是导致这个现象的原因却有很多种。常见的两种是：
--当一个会话视图修改一个数据块，但这个数据块正在被另一个会话修改时。
--当一个会话需要读取一个数据块，但这个数据块正在被另一个会话读取到内存中时。
在新的版本中，第二种情况已经被独立出来，以read by other session取代~
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#

2.Buffer  latch

内存中数据块的存放位置是记录在一个hash列表（cache buffer chains）当中的。 当一个会话需要访问某个数据块时，它首先要搜索这个hash 列表，从列表中获得数据块的地址，然后通过这个地址去访问需要的数据块，这个列表Oracle会使用一个latch来保护它的完整性。 当一个会话需要访问这个列表时，需要获取一个Latch，只有这样，才能保证这个列表在这个会话的浏览当中不会发生变化。
 
产生buffer latch的等待事件的主要原因是：
Buffer chains太长，导致会话搜索这个列表花费的时间太长，使其他的会话处于等待状态。
同样的数据块被频繁访问，就是我们通常说的热快问题。

这个等待事件有两个参数：
Latch addr： 会话申请的latch在SGA中的虚拟地址，通过以下的SQL语句可以根据这个地址找到它对应的Latch名称：
select * from v$latch a,v$latchname b where 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等待事件。
控制文件频繁写入的原因很多，比如：
--日志切换太过频繁，导致控制文件信息相应地需要频繁更新。
--系统I/O 出现瓶颈，导致所有I/O出现等待。
 
这个等待事件包含三个参数：
--Files： Oracle 要写入的控制文件个数。
--Blocks： 写入控制文件的数据块数目。
--Requests：写入控制请求的I/O 次数。
 
4.Control file sequential read

当数据库需要读取控制文件上的信息时，会出现这个等待事件，因为控制文件的信息是顺序写的，所以读取的时候也是顺序的，因此称为控制文件顺序读，它经常发生在以下情况：
--备份控制文件
--RAC 环境下不同实例之间控制文件的信息共享
--读取控制文件的文件头信息
--读取控制文件其他信息
 
这个等待事件有三个参数：
--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。

这种情况通常发生在：
--使用临时表空间排序（内存不足）
--数据的直接加载（使用append方式加载数据）
--并行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的模式。

13.Free buffer waits

当一个会话将数据块从磁盘读到内存中时，它需要到内存中找到空闲的内存空间来存放这些数据块，当内存中没有空闲的空间时，就会产生这个等待；除此之外，还有一种情况就是会话在做一致性读时，需要构造数据块在某个时刻的前映像（image），此时需要申请内存来存放这些新构造的数据块，如果内存中无法找到这样的内存块，也会发生这个等待事件。
 
当数据库中出现比较严重的free buffer waits等待事件时，可能的原因是：
--data buffer 太小，导致空闲空间不够
--内存中的脏数据太多，DBWR无法及时将这些脏数据写到磁盘中以释放空间
 
这个等待事件包含2个参数：
--File#： 需要读取的数据块所在的数据文件的文件号。
--Block#： 需要读取的数据块块号。

--查询阻塞的语句：
SELECT /*+ ORDERED USE_HASH(H,R) */
 h.sid hold_sid, holds.username h_user, holds.lockwait h_lockwait, holds.status h_status, holds.module h_module, holds.row_wait_obj# h_obj, holds.row_wait_row# h_row,
 r.sid wait_sid, waits.username w_user, waits.lockwait w_lockwait, waits.status w_status, waits.module w_module, waits.row_wait_obj# w_obj, waits.row_wait_row# w_row,
 h.type h_type, h.id1 h_id1, h.id2 h_id2, h.lmode h_lmode, h.request h_request, h.ctime h_ctime, h.block h_block,
 r.type r_type, r.id1 r_id1, r.id2 r_id2, r.lmode r_lmode, r.request r_request, r.ctime r_ctime, r.block r_block,
 'alter system kill session ''' || holds.sid || ',' || holds.serial# ||
 '''; -- kill -9 ' || nvl(holdp.spid, 'null') killhold,
 holdsql.sql_text hsql,
 waitsql.sql_text wsql
  FROM v$lock    h,
       v$lock    r,
       v$session holds,
       v$session waits,
       v$process holdp,
       v$sqlarea holdsql,
       v$sqlarea waitsql
 WHERE h.BLOCK = 1 AND
       r.BLOCK = 0 AND
       h.TYPE <> 'MR' AND
       r.TYPE <> 'MR' AND
       h.id1 = r.id1 AND
       h.id2 = r.id2 AND
       h.sid = holds.sid AND
       r.sid = waits.sid AND
       holds.paddr = holdp.addr(+) AND
       holds.sql_address = holdsql.address(+) AND
       holds.sql_hash_value = holdsql.hash_value(+) AND
       waits.sql_address = waitsql.address(+) AND
       waits.sql_hash_value = waitsql.hash_value(+);

14.Latch free

在10g之前的版本里，latch free 等待事件代表了所有的latch等待，在10g以后，一些常用的latch事件已经被独立了出来：

这个等待事件有三个参数：
--Address: 会话等待的latch 地址。
--Number： latch号，通过这个号，可以从v$latchname 视图中找到这个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等待事件，可以考虑如下方法：
--增加redo buffer的大小。
--提升磁盘的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)

当一个在线日志切换到下一个在线日志时，必须保证要切换到的在线日志上的记录的信息（比如一些脏数据块产生的redo log）被写到磁盘上（checkpoint），这样做的原因是，如果一个在线日志文件的信息被覆盖，而依赖这些redo 信息做恢复的数据块尚未被写到磁盘上（checkpoint），此时系统down掉的话，Oracle将没有办法进行实例恢复。

在v$log 视图里记录了在线日志的状态。 通常来说，在线日志有三种状态。
--Active: 这个日志上面保护的信息还没有完成checkpoint。
--Inactive： 这个日志上面保护的信息已完成checkpoint。
--Current： 当前的日志。
 
如果系统中出现大量的log file switch（checkpoint incomplete）等待事件，原因可能是日志文件太小或者日志组太少，所以解决的方法是，增加日志文件的大小或者增加日志组的数量。

这个等待事件没有参数。

23.Log file sync

这是一个用户会话行为导致的等待事件，当一个会话发出一个commit命令时，LGWR进程会将这个事务产生的redo log从log buffer里面写到磁盘上，以确保用户提交的信息被安全地记录到数据库中。会话发出的commit指令后，需要等待LGWR将这个事务产生的redo 成功写入到磁盘之后，才可以继续进行后续的操作，这个等待事件就叫作log file sync。

以下几种情况，可能产生这个等待：
--高提交频率
解决方法是简单的消除不必要的提交，事务是工作单元。工作单元应该是全部成功或全部失败。
--缓慢的I/O子系统
较高的IO吞吐良可以改善log file sync和log file parallel write事件的平均等待时间。频繁的提交会弄乱数据库布局和IO子系统。解决办法是将日志文件放裸设备上或绑定在RAID 0或RAID 0+1中，而不是绑定在RAID 5中。
--过大的日志缓冲区
过大的日志缓冲区也可能延长log file sync等待。大型的日志缓冲区减少后台写入的数量，允许LGWR变得懒惰，并导致更多的重做条目堆积在日志缓冲区中。同时可以调整参数_LOG_IO_SIZE参数，其默认值是LOG_BUFFER的1/3或1MB，取两者之中较小的值。换句话说，你可以具有较大的日志缓冲区，但较小的_LOG_IO_SIZE将增加后台写入，从而减少log file sync的等待时间.
--过小的日志缓冲区
过小的日志缓冲区，还会导致log buffer space等待
--日志组多少与日志大小不合适

这个等待事件包含一个参数：
Buffer#: redo buffer 中需要被写入到磁盘中的buffer。

24.SQL*Net break/reset to client

当出现这个等待事件时，说明服务器端在给客户端发送一个断开连接或者重置连接的请求，正在等待客户的响应，通常的原因是服务器到客户端的网络不稳定导致的。

这个等待事件包含两个参数：
--Driver id: 服务器和客户端连接使用的协议信息。
--Breaks：零表示服务端向客户端发送一个重置（reset）信息，非零表示服务器端向客户端发送一个断开（break）消息。

25.SQL*Net break/reset to dblink

这个等待事件和SQL*Net break/reset to client 相同。 不过它表示的是数据库通过dblink访问另一台数据库时，他们之间建立起一个会话，这个等待事件发生在这个会话之间的通信过程中，同样如果出现这个等待事件，需要检查两台数据库之间的通信问题。

这个等待事件有两个参数：
--Driver id: 服务器和客户端连接使用的协议信息。
--Breaks：零表示服务端向客户端发送一个重置（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: 服务器端从客户端接收到消息的字节数。