oracle常见的等待事件有哪些

共计 10442 个字符，预计需要花费 27 分钟才能阅读完成。

本篇文章给大家分享的是有关 oracle 常见的等待事件有哪些，丸趣 TV 小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着丸趣 TV 小编一起来看看吧。

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: 服务器端从客户端接收到消息的字节数。

以上就是 oracle 常见的等待事件有哪些，丸趣 TV 小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注丸趣 TV 行业资讯频道。