Oracle 常见的33个等待事件
一． 等待事件的相关知识：
1.1 等待事件主要可以分为两类，即空闲(IDLE)等待事件和非空闲(NON-IDLE)等待事件。
1). 空闲等待事件指ORACLE正等待某种工作，在诊断和优化数据库的时候，不用过多注意这部分事件。
2). 非空闲等待事件专门针对ORACLE的活动，指数据库任务或应用运行过程中发生的等待，这些等待事件是在调整数据库的时候需要关注与研究的。
在Oracle 10g中的等待事件有872个，11g中等待事件1116个。 我们可以通过v$event_name 视图来查看等待事件的相关信息。
1.2 查看v$event_name视图的字段结构：
SQL> desc v$event_name;
名称 是否为空? 类型
----------------------------------------- -------- ---------------
EVENT# NUMBER
EVENT_ID NUMBER
NAME VARCHAR2(64)
PARAMETER1 VARCHAR2(64)
PARAMETER2 VARCHAR2(64)
PARAMETER3 VARCHAR2(64)
WAIT_CLASS_ID NUMBER
WAIT_CLASS# NUMBER
WAIT_CLASS VARCHAR2(64)
1.3 查看等待事件总数：
SQL> select count(*) from v$event_name;
COUNT(*)
----------
1116
1.4 查看等待事件分类情况：
/* Formatted on 2010/8/11 16:08:55 (QP5 v5.115.810.9015) */
SELECT wait_class#,
wait_class_id,
wait_class,
COUNT ( * ) AS "count"
FROM v$event_name
GROUP BY wait_class#, wait_class_id, wait_class
ORDER BY wait_class#;
WAIT_CLASS# WAIT_CLASS_ID WAIT_CLASS count
----------- ------------- -------------------- ----------
0 1893977003 Other 717
1 4217450380 Application 17
2 3290255840 Configuration 24
3 4166625743 Administrative 54
4 3875070507 Concurrency 32
5 3386400367 Commit 2
6 2723168908 Idle 94
7 2000153315 Network 35
8 1740759767 User I/O 45
9 4108307767 System I/O 30
10 2396326234 Scheduler 7
11 3871361733 Cluster 50
12 644977587 Queueing 9
1.5 相关的几个视图：
V$SESSION： 代表数据库活动的开始，视为源起。
V$SESSION_WAIT： 视图用以实时记录活动SESSION的等待情况，是当前信息。
V$SESSION_WAIT_HISTORY： 是对V$SESSION_WAIT的简单增强，记录活动SESSION的最近10次等待。
V$SQLTEXT： 当数据库出现瓶颈时，通常可以从V$SESSION_WAIT找到那些正在等待资源的SESSION，通过SESSION的SID，联合V$SESSION和V$SQLTEXT视图就可以捕获这些SESSION正在执行的SQL语句。
V$ACTIVE_SESSION_HISTORY: 是ASH的核心，用以记录活动SESSION的历史等待信息，每秒采样一次，这部分内容记录在内存中，期望值是记录一个小时的内容。
WRH#_ACTIVE_SESSION_HISTORY : 是V$ACTIVE_SESSION_HISTORY在AWR的存储地。
V$ACTIVE_SESSION_HISTORY: 中的信息会被定期(每小时一次)的刷新到负载库中，并缺省保留一个星期用于分析。
DBA_HIST_ACTIVE_SESS_HISTORY: 视图是WRH#_ACTIVE_SESSION_HISTORY视图和其他几个视图的联合展现，通常通过这个视图进行历史数据的访问。
V$SYSTEM_EVENT 由于V$SESSION记录的是动态信息，和SESSION的生命周期相关，而并不记录历史信息，所以ORACLE提供视图V$SYSTEM_EVENT来记录数据库自启动以来所有等待事件的汇总信息。通过这个视图，用户可以迅速获得数据库运行的总体概况。
二． 33个常见的等待事件
1. Buffer busy waits
从本质上讲，这个等待事件的产生仅说明了一个会话在等待一个Buffer（数据块），但是导致这个现象的原因却有很多种。常见的两种是：
当一个会话视图修改一个数据块，但这个数据块正在被另一个会话修改时。
当一个会话需要读取一个数据块，但这个数据块正在被另一个会话读取到内存中时。
Oracle 操作的最小单位是块（Block），即使你要修改一条记录，也需要对这条记录所在的这个数据块做操作。 当你对这个数据块做修改时，其他的会话将被阻止对这个数据块上的数据做修改（即使其他用户修改的不是当前用户修改的数据），但是可以以一致性的方式读取这个数据块（from undo）。当前的用户修改完这个数据块后，将会立即释放掉加在这个数据块上的排他锁，这样另一个会话就可以继续修改它。 修改操作是一个非常短暂的时间，这种加锁的机制我们叫Latch。
当一个会话修改一个数据块时，是按照以下步骤来完成的：
以排他的方式获得这个数据块（Latch）
修改这个数据块。
释放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的等待事件的主要原因是：
Buffer chains太长，导致会话搜索这个列表花费的时间太长，使其他的会话处于等待状态。
同样的数据块被频繁访问，就是我们通常说的热快问题。
产生buffer chains太长，我们可以使用多个buffer 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等待事件。
控制文件频繁写入的原因很多，比如：
日志切换太过频繁，导致控制文件信息相应地需要频繁更新。
系统I/O 出现瓶颈，导致所有I/O出现等待。
当系统出现日志切换过于频繁的情形时，可以考虑适当地增大日志文件的大小来降低日志切换频率。
当系统出现大量的control file parallel write 等待事件时，可以通过比如降低控制文件的拷贝数量，将控制文件的拷贝存放在不同的物理磁盘上的方式来缓解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的模式。
可以使用如下SQL 查看当前会话等待的enqueue名称和类型：
/* Formatted on 2010/8/12 11:00:56 (QP5 v5.115.810.9015) */
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 Cache 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
关于enqueue 可以参考如下的连接：
Wait Events - Enqueue Waits
aspx">http://www.toadworld.com/KNOWLEDGE/KnowledgeXpertforOracle/tabid/648/TopicID/WE1/Default.aspx
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)
当一个在线日志切换到下一个在线日志时，必须保证要切换到的在线日志上的记录的信息（比如一些脏数据块产生的redo log）被写到磁盘上（checkpoint），这样做的原因是，如果一个在线日志文件的信息被覆盖，而依赖这些redo 信息做恢复的数据块尚未被写到磁盘上（checkpoint），此时系统down掉的话，Oracle将没有办法进行实例恢复。
在v$log 视图里记录了在线日志的状态。 通常来说，在线日志有三种状态。
Active: 这个日志上面保护的信息还没有完成checkpoint。
Inactive： 这个日志上面保护的信息已完成checkpoint。
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发送给另一个服务器消息的字节数。
整理自《让Oracle 跑的更快》
------------------------------------------------------------------------------
Blog： http://blog.csdn.net/tianlesoftware
点击复制链接 与QQ/MSN好友分享!分享到： 您对本文章有什么意见或着疑问吗？请到论坛讨论您的关注和建议是我们前行的参考和动力 点击全部查看上一篇：Oracle 等待事件
下一篇：使用 Tkprof 分析 ORACLE 跟踪文件
http://www.2cto.com/database/201110/107267.html
等待事件的源起
等待事件的概念大概是从ORACLE 7.0.12中引入的，大致有100个等待事件。在ORACLE 8.0中这个数目增大到了大约150个，在ORACLE 8I中大约有220个事件，在ORACLE 9IR2中大约有400个等待事件，而在最近ORACLE 10GR2中，大约有874个等待事件。
虽然不同版本和组件安装可能会有不同数目的等待事件，但是这些等待事件都可以通过查询V$EVENT_NAME视图获得：
SQL> select * from v$version;
BANNER
----------------------------------------------------------------
Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Prod
PL/SQL Release 10.2.0.1.0 - Production
CORE 10.2.0.1.0 Production
TNS for 32-bit Windows: Version 10.2.0.1.0 - Production
NLSRTL Version 10.2.0.1.0 – Production
SQL> select count(*) from v$event_name;
COUNT(*)
----------
872
ORACLE的等待事件，主要可以分为两类，即空闲(IDLE)等待事件和非空闲(NON-IDLE)等待事件。
1). 空闲等待事件指ORACLE正等待某种工作，在诊断和优化数据库的时候，不用过多注意这部分事件。
2). 非空闲等待事件专门针对ORACLE的活动，指数据库任务或应用运行过程中发生的等待，这些等待事件是在调整数据库的时候需要关注与研究的。
下面来看一下ORACLE 10GR2中主要分类及各类等待事件的个数：
SQL> select wait_class#,wait_class_id,wait_class,count(*) as "count"
2 from v$event_name
3 group by wait_class#,wait_class_id,wait_class
4 order by wait_class#;
WAIT_CLASS# WAIT_CLASS_ID WAIT_CLASS count
----------- ------------- ------------------------------ ----------
0 1893977003 Other 588
1 4217450380 Application 12
2 3290255840 Configuration 23
3 4166625743 Administrative 46
4 3875070507 Concurrency 24
5 3386400367 Commit 1
6 2723168908 Idle 62
7 2000153315 Network 26
8 1740759767 User I/O 17
9 4108307767 System I/O 24
10 2396326234 Scheduler 2
11 3871361733 Cluster 47
12 rows selected.
常见的空闲事件有:
?dispatcher timer
?lock element cleanup
?Null event
?parallel query dequeue wait
?parallel query idle wait - Slaves
?pipe get
?PL/SQL lock timer
?pmon timer- pmon
?rdbms ipc message
?slave wait
?smon timer
?SQL*Net break/reset to client
?SQL*Net message from client
?SQL*Net message to client
?SQL*Net more data to client
?virtual circuit status
?client message
一些常见的非空闲等待事件有:
?db file scattered read
?db file sequential read
?buffer busy waits
?free buffer waits
?enqueue
?latch free
?log file parallel write
? log file sync
几个视图的总结：
V$SESSION 代表数据库活动的开始，视为源起。
V$SESSION_WAIT 视图用以实时记录活动SESSION的等待情况，是当前信息。
V$SESSION_WAIT_HISTORY 是对V$SESSION_WAIT的简单增强，记录活动SESSION的最近10次等待。
V$ACTIVE_SESSION_HISTORY 是ASH的核心，用以记录活动SESSION的历史等待信息，每秒采样一次，这部分内容记录在内存中，期望值是记录一个小时的内容。
WRH#_ACTIVE_SESSION_HISTORY 是V$ACTIVE_SESSION_HISTORY在AWR的存储地。
V$ACTIVE_SESSION_HISTORY中的信息会被定期(每小时一次)的刷新到负载库中，并缺省保留一个星期用于分析。
DBA_HIST_ACTIVE_SESS_HISTORY视图是WRH#_ACTIVE_SESSION_HISTORY视图和其他几个视图的联合展现，通常通过这个视图进行历史数据的访问。
V$SYSTEM_EVENT 由于V$SESSION记录的是动态信息，和SESSION的生命周期相关，而并不记录历史信息，所以ORACLE提供视图V$SYSTEM_EVENT来记录数据库自启动以来所有等待事件的汇总信息。通过这个视图，用户可以迅速获得数据库运行的总体概况。
V$SQLTEXT 当数据库出现瓶颈时，通常可以从V$SESSION_WAIT找到那些正在等待资源的SESSION，通过SESSION的SID，联合V$SESSION和V$SQLTEXT视图就可以捕获这些SESSION正在执行的SQL语句。
重要等待事件
1. Db file sequential read（数据文件顺序读取）
Db file sequential read是个非常常见的I/O相关的等待事件，通常显示与单个数据块相关的读取操作，在大多数情况下，读取一个索引块或者通过索引读取一个数据块时，都会记录这个等待。
这个等待事件有3个参数P1、P2、P3，其中P1代表Oracle要读取的文件的绝对文件号，P2代表Oracle从这个文件中开始读取的起始数据块块号，P3代表读取的Block数量，通常这个值为1，表明是单个Block被读取。
SQL> select name,parameter1,parameter2,parameter3 from v$event_name where name='db file sequential read';
NAME PARAMETER1 PARAMETER2 PARAMETER3
------------------------------ ---------- ---------- ----------
db file sequential read file# block# blocks
如果这个等待事件比较显著，可能表示在多表连接中，表的连接顺序存在问题，可能没有正确的使用驱动表；或者可能索引的使用存在问题，并非索引总是最好的选择。
在大多数情况下，通过索引可以更为快速地获取记录，所以对于一个编码规范、调整良好的数据库，这个等待事件很大通常是正常的。但是在很多情况下，使用索引并不是最佳的选择，比如读取较大表中大量的数据，全表扫描可能会明显快于索引扫描，所以在开发中就应该注意，对于这样的查询应该避免使用索引扫描。
从Oracle 9iR2开始，Oracle引入了段级统计信息收集的新特性，收集的统计信息共有11类：
Select * from v$segstat_name;
在Oracle 10gR2中，这类统计信息增加为15个。
对于CBO模式下的数据库，应当及时收集统计信息，使SQL可以选择正确的执行计划，避免因为统计信息陈旧而导致的执行错误等。
2. Db file scattered read（数据文件离散读取）
SQL> select * from v$event_name where name='db file scattered read';
EVENT# EVENT_ID NAME PARAMETER1 PARAMETER2 PARAMETER3
---------- ---------- ------------------------- ---------- ---------- ----------
188 506183215 db file scattered read file# block# blocks
从V$EVENT_NAME视图可以看到，该事件有3个参数，分别代表文件号、起始数据块号、数据块的数量。
起始数据块号加上数据块的数量，这意味着Oracle session正在等待多块连续读操作的完成。这个操作可能与全表扫描（Full table scan）或者快速全索引扫描（Index Fast Full Scan）的连续读取相关。根据经验，通常大量的db file scattered read等待可能意味着应用问题或者索引缺失。
在实际环境的诊断过程中，可以通过v$session_wait视图发现session的等待，再结合其他视图找到存在问题的SQL等根本原因，从而从根本上解决问题。当这个等待事件比较显著时，也可结合v$session_longops动态性能视图来进行诊断，该视图记录了长时间（运行时间超过6秒的）运行的事务。
从Oracle 9i开始，Oracle新增加了一个视图V$SQL_PLAN用于记录当前系统Library Cache中SQL语句的执行计划，可以通过这个视图找到存在问题的SQL语句。
通过V$SQL_PLAN视图，可以获得大量有用的信息：
获得全表扫描的对象
Select distinct object_name,object_owner from v$sql_plan p Where p.operation='TABLE ACCESS'and p.options='FULL' and object_owner='SYS';
获得全索引扫描的对象
Select distinct object_name,object_owner from v$sql_plan p Where p.operation='INDEX' and p.options='FULL SCAN' and object_owner='SYS';
通过V$SQL_PLAN和V$SQLTEXT联合，获得全表扫描的SQL语句
Select sql_text from v$sqltext t,v$sql_plan p Where t.hash_value=p.hash_value And p.operation='TABLE ACCESS' And p.options='FULL' Order by p.hash_value,t.piece;
3. Direct path read/write（直接路径读/写）
直接路径读通常发生在Oracle直接读取数据到PGA时，这个读取不需要经过SGA。直接路径读等待事件的3个参数分别是：file#（指绝对文件号）、first block#和block数量。
这类读取通常在以下情况被使用：
磁盘排序IO操作
并行查询从属进程
预读操作
最常见的是第一种情况。在DSS系统中，存在大量的Direct path read是很正常的，但是在OLTP系统中，通常显著的直接路径读都意味着系统应用存在问题，从而导致大量的磁盘排序读取操作。
直接路径写通常发生在Oracle直接从PGA写数据到数据文件或临时文件，这个写操作可以绕过SGA。直接路径写等待事件的3个参数分别是：file#（指绝对文件号）、first block#和block数量。
这类读取通常在以下情况被使用：
直接路径加载
并行DML操作
磁盘排序
对未缓存的“LOB”段的写入，随后会记录为direct path write(lob)等待
最常见的直接路径写，多数因为磁盘排序导致。对于这一写入等待，应该找到I/O操作最为频繁的数据文件（如果有过多的排序操作，很有可能就是临时文件），分散负载，加快其写入操作。
如果系统存在过多的磁盘排序，会导致临时表空间操作频繁，对于这种情况，可以考虑为不同用户分配不同的临时表空间，使用多个临时文件，写入不同磁盘或者裸设备，从而降低竞争提高性能。
日志文件相关等待
SQL> select name from v$event_name where name like '%log%';
NAME
----------------------------------------------------------------
log switch/archive
log file sequential read
log file single write
log file parallel write
log buffer space
log file switch (checkpoint incomplete)
log file switch (archiving needed)
log file switch (clearing log file)
switch logfile command
log file switch completion
log file sync
STREAMS capture process waiting for archive log
已选择12行。
4. Log File Switch（日志文件切换）
Log File Switch当日志文件发生切换时出现，在数据库进行日志切换时，LGWR需要关闭当前日志组，切换并打开下一个日志组，在这个切换过程中，数据库的所有DML操作都处于停顿状态，直至这个切换完成。
Log File Switch主要包含两个子事件：
1. log file switch(achiving needed)，即日志切换（需要归档）
这个等待事件出现时通常是因为日志组循环写满以后，在需要覆盖先前日志时，发现日志归档尚未完成，出现该等待。由于Redo不能写出，该等待出现时，数据库将陷于停顿状态。
出现该等待，可能表示I/O存在问题、归档进程写出缓慢，也有可能是日志组设置不合理等原因导致。针对不同原因，可以考虑采用的解决方法有：
可以考虑增大日志文件和增加日志组；
移动归档文件到快速磁盘；
调整log_archive_max_processes参数等；
2. log file switch(checkpoint incomplete)，即日志切换（检查电未完成）
当所有的日志组都写满之后。LGWR试图覆盖某个日志文件，如果这时数据库没有完成写出由这个日志文件所保护的脏数据时（检查点未完成），该等待事件出现。该等待出现时，数据库同样将陷于停顿状态。
该等待事件通常表示DBWR写出速度太慢或者I/O存在问题。为解决该问题，可能需要考虑增加额外的DBWR或者增加日志组或日志文件大小。
5. Log File Sync（日志文件同步）
当一个用户提交或回滚数据时，LGWR将会话期的重做由日志缓冲区写入到重做日志中，LGWR完成任务以后会通知用户进程。日志文件同步过程（Log File Sync）必须等待这一过程成功完成。对于回滚操作，该事件记录从用户发出Rollback命令道回滚完成的时间。
如果该等待过多，可能说明LGWR的写出效率低下，或者系统提交过于频繁。针对该问题，可以通过log file parallel write等待事件或User Commits、User Rollback等统计信息来观察提交或回滚次数。
可能的解决方案主要有：
1). 提高LGWR性能，尽量使用快速磁盘，不要把redo log file存放在RAID5的磁盘上；RAID5 对于频繁写入得系统会带来较大的性能损失，可以考虑使用文件系统直接输入/输出，或者使用裸设备(raw device)，这样可以获得写入的性能提高。
2). 使用批量提交；
3). 适当使用NOLOGGING/UNRECOVERABLE等选项
6. Log File Single Write
该事件仅与写日志文件头块相关，通常发生在增加新的组成员和增进序列号（Log switch）时。头块写单个进行，因为头块的部分信息是文件号，每个文件不同。更新日志文件头这个操作在后台完成，一般很少出现等待，无需太多关注。
7. Log File Parallel Write
从Log Buffer写Redo记录到日志文件，主要指常规写操作（相对于Log File Sync）。如果Log Group存在多个组成员，当Flush Log Buffer时，写操作是并行的，这时候此等待事件可能出现。
尽管这个写操作并行处理，直到所有I/O 操作完成该写操作才会完成(如果你的磁盘支持异步IO或者使用IO SLAVE，那么即使只有一个redo log file member,也有可能出现此等待)。
这个参数和log file sync 时间相比较可以用来衡量log file 的写入成本。通常称为同步成本率。
8. Log Buffer Space（日志缓冲空间）
当数据库产生日志的速度比LGWR的写出速度快，或者当日志切换太慢时，就会发生这种等待。这个等待出现时，通常表明Redo log buffer过小，为解决这个问题，可以考虑增大日志文件的大小或者增加日志缓冲器的大小。
另一个可能的原因是磁盘I/O存在瓶颈，可以考虑使用写入速度更快的磁盘。在允许的条件下设置，可以考虑使用裸设备来存放日志文件，提高写入效率。在一般的系统中，最低的标准是，不要把日志文件和数据文件存放在一起，因为通常日志文件只写不读，分离存放可以获得性能提升，尽量使用RAID10而不是RAID5磁盘来存储日志文件。
9. Enqueue(队列等待)
Enqueue是一种保护共享资源的锁定机制。该锁定机制保护共享资源，以避免因并发操作而损坏数据，比如通过锁定保护一行记录，避免多个用户同时更新。Enqueue采用排队机制，即FIFO(先进先出)来控制资源的使用。
Enqueue是一组锁定事件的集合，如果数据库中这个等待事件比较显著，还需要进一步追踪是哪一个类别的锁定引发了数据库等待。
SQL> select name,wait_class from v$event_name where name like '%enq%' and rownum<11;
--这里记录很多 只去取出了前10条而已
NAME WAIT_CLASS
------------------------- ------------------------------------------------------
enq: PW - flush prewarm b Application
enq: RO - contention Application
enq: RO - fast object reu Application
enq: KO - fast object che Application
enq: MV - datafile move Administrative
enq: TM - contention Application
enq: ST - contention Configuration
enq: TX - row lock conten Application
enq: TX - allocate ITL en Configuration
enq: TX - index contentio Concurrency
已选择10行。
10. Latch Free(闩锁释放)
Latch Free通常被称为闩锁释放，这个名称常常引起误解，实际上应该在前面加上一个”等待(WAIT)”，当数据库出现这个等待时，说明有进程正在等待某个Latch被释放，也就是Waiting Latch Free。
Latch是一种低级排队(串行)机制，用于保护SGA中共享内存结构。Latch就像是一种快速的被获取和释放的内存锁，用于防止共享内存结构被多个用户同时访问。
如果latch不可用，就会记录latch释放失败(latch free miss )。有两种与闩有关的类型:
1) 立刻。
2) 可以等待。
假如一个进程试图在立刻模式下获得闩，而该闩已经被另外一个进程所持有，如果该闩不能立可用的话，那么该进程就不会为获得该闩而等待。它将继续执行另一个操作。
大多数latch问题都与以下操作相关:
没有很好的是用绑定变量(library cache latch)、重作生成问题(redo allocation latch)、缓冲存储竞争问题(cache buffers LRU chain)，以及buffer cache中的存在"热点"块(cache buffers chain)。
通常我们说，如果想设计一个失败的系统，不考虑绑定变量，这一个条件就够了，对于异构性强的系统，不使用绑定变量的后果是极其严重的。
另外也有一些latch等待与bug有关，应当关注Metalink相关bug的公布及补丁的发布。当latch miss ratios大于0.5%时，就应当研究这一问题。
Oracle的latch机制是竞争，其处理类似于网络里的CSMA/CD，所有用户进程争夺latch， 对于愿意等待类型(willing-to-wait)的latch,如果一个进程在第一次尝试中没有获得latch,那么它会等待并且再尝试一次,如果经过_spin_count次争夺不能获得latch, 然后该进程转入睡眠状态，持续一段指定长度的时间，然后再次醒来，按顺序重复以前的步骤.在8i/9i中默认值是_spin_count=2000。
如果SQL语句不能调整，在8.1.6版本以上，Oracle提供了一个新的初始化参数: CURSOR_SHARING可以通过设置CURSOR_SHARING = force 在服务器端强制绑定变量。设置该参数可能会带来一定的副作用，对于Java的程序，有相关的bug，具体应用应该关注Metalink的bug公告。
11. Free Buffer-释放缓冲区
这个等待事件表明系统正在等待内存中的可用空间，这说明当前Buffer 中已经没有Free 的内存空间。如果应用设计良好，SQL 书写规范，充分绑定变量，那这种等待可能说明Buffer Cache 设置的偏小，你可能需要增大DB_BUFFER_CACHE。
Free Buffer 等待可能说明DBWR 的写出速度不够，或者磁盘存在严重的竞争，可以需要考虑增加检查点、使用更多的DBWR 进程，或者增加物理磁盘的数量,分散负载，平衡IO。
12. Buffer Busy-缓冲区忙
该等待事件表示正在等待一个以unshareable方式使用的缓冲区，或者表示当前正在被读入buffer cache。一般来说Buffer Busy Wait不应大于1%。检查缓冲等待统计部分(或V$WAITSTAT)，看一下等待是否位于段头(Segment Header)。如果是，可以考虑增加自由列表(freelist，对于Oracle8i DMT)或者增加freelist groups(在很多时候这个调整是立竿见影的，在8.1.6之前，这个freelists参数不能动态修改;在8.1.6及以后版本，动态修改feelists需要设置COMPATIBLE至少为8.1.6).
如果这一等待位于undo header，可以通过增加回滚段(rollback segment)来解决缓冲区的问题。如果等待位于undo block上，我们可能需要检查相关应用，适当减少大规模的一致性读取，或者降低一致性读取(consistent read)的表中的数据密度或者增大DB_CACHE_SIZE。
如果等待处于data block，可以考虑将频繁并发访问的表或数据移到另一数据块或者进行更大范围的分布(可以增加pctfree值 ，扩大数据分布，减少竞争)，以避开这个"热点"数据块，或者可以考虑增加表中的自由列表或使用本地化管理的表空间(Locally Managed Tablespaces)。
如果等待处于索引块，应该考虑重建索引、分割索引或使用反向键索引。为了防止与数据块相关的缓冲忙等待，也可以使用较小的块:在这种情况下，单个块中的记录就较少，所以这个块就不是那么"繁忙";或者可以设置更大的pctfree,使数据扩大物理分布，减少记录间的热点竞争。
在执行DML (insert/update/ delete)时，Oracle向数据块中写入信息，对于多事务并发访问的数据表，关于ITL的竞争和等待可能出现，为了减少这个等待，可以增加initrans，使用多个ITL槽。在Oracle9i 中，引入了一个新概念:ASSM(Segment Space Management Auto)。通过这个新特性Oracle 使用位图来管理空间使用。
ASSM 结合LMT 彻底改变了Oracle 的存储机制，位图freelist 能够减轻缓冲区忙等待(buffer busy wait)，这个问题在Oracle9i 以前的版本里曾是一个严重的问题。
Oracle 宣称ASSM 显著地提高了DML 并发操作的性能，因为(同一个)位图的不同部分可以被同时使用，这样就消除了寻找剩余空间的串行化。根据Oracle 的测试结果，使用位图freelist 会消除所有分段头部(对资源)的争夺，还能获得超快的并发插入操作。在Oracle9i 之中，Buffer Busy wait 不再常见!
13. control file parallel write-控制文件并行写
当server 进程更新所有控制文件时，这个事件可能出现。如果等待很短，可以不用考虑。如果等待时间较长，检查存放控制文件的物理磁盘I/O 是否存在瓶颈。
多个控制文件是完全相同的拷贝，用于镜像以提高安全性。对于业务系统，多个控制文件应该存放在不同的磁盘上，一般来说三个是足够的，如果只有两个物理硬盘，那么两个控制文件也是可以接受的。在同一个磁盘上保存多个控制文件是不具备实际意义的。减少这个等待，可以考虑如下方法:
减少控制文件的个数(在确保安全的前提下)
如果系统支持，使用异步IO
转移控制文件到IO 负担轻的物理磁盘
14. control file sequential read/ control file single write 控制文件连续读/控制文件单个写对单个控制文件I/O 存在问题时，这两个事件会出现。如果等待比较明显，检查单个控制文件，看存放位置是否存在I/O 瓶颈。
15. direct path write-直接路径写该等待发生在，系统等待确认所有未完成的异步I/O 都已写入磁盘。
对于这一写入等待，我们应该找到I/O 操作最为频繁的数据文件(如果有过多的排序操作，很有可能就是临时文件)，分散负载，加快其写入操作。
如果系统存在过多的磁盘排序，会导致临时表空间操作频繁，对于这种情况，可以考虑使用Local管理表空间，分成多个小文件，写入不同磁盘或者裸设备。
16. Idle Event-空闲事件
一般来说，空闲等待是指系统因为无事可做的等待，或者等待用户的请求或响应等，通常我们可以忽略这些等待事件。空闲事件可以通过stats$idle_event 表查询得到。
我们看一下系统的主要空闲等待事件，对这些事件大家应该有个大致的印象，如果你的Top 5 等待事件中，主要都是这些事件，那么一般来说你的系统是比价清闲的。
注： 整理自网络
一． 等待事件的相关知识：
1.1 等待事件主要可以分为两类，即空闲(IDLE)等待事件和非空闲(NON-IDLE)等待事件。
1). 空闲等待事件指ORACLE正等待某种工作，在诊断和优化数据库的时候，不用过多注意这部分事件。
2). 非空闲等待事件专门针对ORACLE的活动，指数据库任务或应用运行过程中发生的等待，这些等待事件是在调整数据库的时候需要关注与研究的。
在Oracle 10g中的等待事件有872个，11g中等待事件1116个。 我们可以通过v$event_name 视图来查看等待事件的相关信息。
1.2 查看v$event_name视图的字段结构：
SQL> desc v$event_name;
名称 是否为空? 类型
----------------------------------------- -------- ---------------
EVENT# NUMBER
EVENT_ID NUMBER
NAME VARCHAR2(64)
PARAMETER1 VARCHAR2(64)
PARAMETER2 VARCHAR2(64)
PARAMETER3 VARCHAR2(64)
WAIT_CLASS_ID NUMBER
WAIT_CLASS# NUMBER
WAIT_CLASS VARCHAR2(64)
1.3 查看等待事件总数：
SQL> select count(*) from v$event_name;
COUNT(*)
----------
1116
1.4 查看等待事件分类情况：
/* Formatted on 2010/8/11 16:08:55 (QP5 v5.115.810.9015) */
SELECT wait_class#,
wait_class_id,
wait_class,
COUNT ( * ) AS "count"
FROM v$event_name
GROUP BY wait_class#, wait_class_id, wait_class
ORDER BY wait_class#;
WAIT_CLASS# WAIT_CLASS_ID WAIT_CLASS count
----------- ------------- -------------------- ----------
0 1893977003 Other 717
1 4217450380 Application 17
2 3290255840 Configuration 24
3 4166625743 Administrative 54
4 3875070507 Concurrency 32
5 3386400367 Commit 2
6 2723168908 Idle 94
7 2000153315 Network 35
8 1740759767 User I/O 45
9 4108307767 System I/O 30
10 2396326234 Scheduler 7
11 3871361733 Cluster 50
12 644977587 Queueing 9
1.5 相关的几个视图：
V$SESSION： 代表数据库活动的开始，视为源起。
V$SESSION_WAIT： 视图用以实时记录活动SESSION的等待情况，是当前信息。
V$SESSION_WAIT_HISTORY： 是对V$SESSION_WAIT的简单增强，记录活动SESSION的最近10次等待。
V$SQLTEXT： 当数据库出现瓶颈时，通常可以从V$SESSION_WAIT找到那些正在等待资源的SESSION，通过SESSION的SID，联合V$SESSION和V$SQLTEXT视图就可以捕获这些SESSION正在执行的SQL语句。
V$ACTIVE_SESSION_HISTORY: 是ASH的核心，用以记录活动SESSION的历史等待信息，每秒采样一次，这部分内容记录在内存中，期望值是记录一个小时的内容。
WRH#_ACTIVE_SESSION_HISTORY : 是V$ACTIVE_SESSION_HISTORY在AWR的存储地。
V$ACTIVE_SESSION_HISTORY: 中的信息会被定期(每小时一次)的刷新到负载库中，并缺省保留一个星期用于分析。
DBA_HIST_ACTIVE_SESS_HISTORY: 视图是WRH#_ACTIVE_SESSION_HISTORY视图和其他几个视图的联合展现，通常通过这个视图进行历史数据的访问。
V$SYSTEM_EVENT 由于V$SESSION记录的是动态信息，和SESSION的生命周期相关，而并不记录历史信息，所以ORACLE提供视图V$SYSTEM_EVENT来记录数据库自启动以来所有等待事件的汇总信息。通过这个视图，用户可以迅速获得数据库运行的总体概况。
二． 33个常见的等待事件
1. Buffer busy waits
从本质上讲，这个等待事件的产生仅说明了一个会话在等待一个Buffer（数据块），但是导致这个现象的原因却有很多种。常见的两种是：
当一个会话视图修改一个数据块，但这个数据块正在被另一个会话修改时。
当一个会话需要读取一个数据块，但这个数据块正在被另一个会话读取到内存中时。
Oracle 操作的最小单位是块（Block），即使你要修改一条记录，也需要对这条记录所在的这个数据块做操作。 当你对这个数据块做修改时，其他的会话将被阻止对这个数据块上的数据做修改（即使其他用户修改的不是当前用户修改的数据），但是可以以一致性的方式读取这个数据块（from undo）。当前的用户修改完这个数据块后，将会立即释放掉加在这个数据块上的排他锁，这样另一个会话就可以继续修改它。 修改操作是一个非常短暂的时间，这种加锁的机制我们叫Latch。
当一个会话修改一个数据块时，是按照以下步骤来完成的：
以排他的方式获得这个数据块（Latch）
修改这个数据块。
释放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的等待事件的主要原因是：
Buffer chains太长，导致会话搜索这个列表花费的时间太长，使其他的会话处于等待状态。
同样的数据块被频繁访问，就是我们通常说的热快问题。
产生buffer chains太长，我们可以使用多个buffer 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等待事件。
控制文件频繁写入的原因很多，比如：
日志切换太过频繁，导致控制文件信息相应地需要频繁更新。
系统I/O 出现瓶颈，导致所有I/O出现等待。
当系统出现日志切换过于频繁的情形时，可以考虑适当地增大日志文件的大小来降低日志切换频率。
当系统出现大量的control file parallel write 等待事件时，可以通过比如降低控制文件的拷贝数量，将控制文件的拷贝存放在不同的物理磁盘上的方式来缓解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的模式。
可以使用如下SQL 查看当前会话等待的enqueue名称和类型：
/* Formatted on 2010/8/12 11:00:56 (QP5 v5.115.810.9015) */
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 Cache 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
关于enqueue 可以参考如下的连接：
Wait Events - Enqueue Waits
aspx">http://www.toadworld.com/KNOWLEDGE/KnowledgeXpertforOracle/tabid/648/TopicID/WE1/Default.aspx
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)
当一个在线日志切换到下一个在线日志时，必须保证要切换到的在线日志上的记录的信息（比如一些脏数据块产生的redo log）被写到磁盘上（checkpoint），这样做的原因是，如果一个在线日志文件的信息被覆盖，而依赖这些redo 信息做恢复的数据块尚未被写到磁盘上（checkpoint），此时系统down掉的话，Oracle将没有办法进行实例恢复。
在v$log 视图里记录了在线日志的状态。 通常来说，在线日志有三种状态。
Active: 这个日志上面保护的信息还没有完成checkpoint。
Inactive： 这个日志上面保护的信息已完成checkpoint。
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发送给另一个服务器消息的字节数。
整理自《让Oracle 跑的更快》
------------------------------------------------------------------------------
Blog： http://blog.csdn.net/tianlesoftware
点击复制链接 与QQ/MSN好友分享!分享到： 您对本文章有什么意见或着疑问吗？请到论坛讨论您的关注和建议是我们前行的参考和动力 点击全部查看上一篇：Oracle 等待事件
下一篇：使用 Tkprof 分析 ORACLE 跟踪文件
http://www.2cto.com/database/201110/107267.html
等待事件的源起
等待事件的概念大概是从ORACLE 7.0.12中引入的，大致有100个等待事件。在ORACLE 8.0中这个数目增大到了大约150个，在ORACLE 8I中大约有220个事件，在ORACLE 9IR2中大约有400个等待事件，而在最近ORACLE 10GR2中，大约有874个等待事件。
虽然不同版本和组件安装可能会有不同数目的等待事件，但是这些等待事件都可以通过查询V$EVENT_NAME视图获得：
SQL> select * from v$version;
BANNER
----------------------------------------------------------------
Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 - Prod
PL/SQL Release 10.2.0.1.0 - Production
CORE 10.2.0.1.0 Production
TNS for 32-bit Windows: Version 10.2.0.1.0 - Production
NLSRTL Version 10.2.0.1.0 – Production
SQL> select count(*) from v$event_name;
COUNT(*)
----------
872
ORACLE的等待事件，主要可以分为两类，即空闲(IDLE)等待事件和非空闲(NON-IDLE)等待事件。
1). 空闲等待事件指ORACLE正等待某种工作，在诊断和优化数据库的时候，不用过多注意这部分事件。
2). 非空闲等待事件专门针对ORACLE的活动，指数据库任务或应用运行过程中发生的等待，这些等待事件是在调整数据库的时候需要关注与研究的。
下面来看一下ORACLE 10GR2中主要分类及各类等待事件的个数：
SQL> select wait_class#,wait_class_id,wait_class,count(*) as "count"
2 from v$event_name
3 group by wait_class#,wait_class_id,wait_class
4 order by wait_class#;
WAIT_CLASS# WAIT_CLASS_ID WAIT_CLASS count
----------- ------------- ------------------------------ ----------
0 1893977003 Other 588
1 4217450380 Application 12
2 3290255840 Configuration 23
3 4166625743 Administrative 46
4 3875070507 Concurrency 24
5 3386400367 Commit 1
6 2723168908 Idle 62
7 2000153315 Network 26
8 1740759767 User I/O 17
9 4108307767 System I/O 24
10 2396326234 Scheduler 2
11 3871361733 Cluster 47
12 rows selected.
常见的空闲事件有:
?dispatcher timer
?lock element cleanup
?Null event
?parallel query dequeue wait
?parallel query idle wait - Slaves
?pipe get
?PL/SQL lock timer
?pmon timer- pmon
?rdbms ipc message
?slave wait
?smon timer
?SQL*Net break/reset to client
?SQL*Net message from client
?SQL*Net message to client
?SQL*Net more data to client
?virtual circuit status
?client message
一些常见的非空闲等待事件有:
?db file scattered read
?db file sequential read
?buffer busy waits
?free buffer waits
?enqueue
?latch free
?log file parallel write
? log file sync
几个视图的总结：
V$SESSION 代表数据库活动的开始，视为源起。
V$SESSION_WAIT 视图用以实时记录活动SESSION的等待情况，是当前信息。
V$SESSION_WAIT_HISTORY 是对V$SESSION_WAIT的简单增强，记录活动SESSION的最近10次等待。
V$ACTIVE_SESSION_HISTORY 是ASH的核心，用以记录活动SESSION的历史等待信息，每秒采样一次，这部分内容记录在内存中，期望值是记录一个小时的内容。
WRH#_ACTIVE_SESSION_HISTORY 是V$ACTIVE_SESSION_HISTORY在AWR的存储地。
V$ACTIVE_SESSION_HISTORY中的信息会被定期(每小时一次)的刷新到负载库中，并缺省保留一个星期用于分析。
DBA_HIST_ACTIVE_SESS_HISTORY视图是WRH#_ACTIVE_SESSION_HISTORY视图和其他几个视图的联合展现，通常通过这个视图进行历史数据的访问。
V$SYSTEM_EVENT 由于V$SESSION记录的是动态信息，和SESSION的生命周期相关，而并不记录历史信息，所以ORACLE提供视图V$SYSTEM_EVENT来记录数据库自启动以来所有等待事件的汇总信息。通过这个视图，用户可以迅速获得数据库运行的总体概况。
V$SQLTEXT 当数据库出现瓶颈时，通常可以从V$SESSION_WAIT找到那些正在等待资源的SESSION，通过SESSION的SID，联合V$SESSION和V$SQLTEXT视图就可以捕获这些SESSION正在执行的SQL语句。
重要等待事件
1. Db file sequential read（数据文件顺序读取）
Db file sequential read是个非常常见的I/O相关的等待事件，通常显示与单个数据块相关的读取操作，在大多数情况下，读取一个索引块或者通过索引读取一个数据块时，都会记录这个等待。
这个等待事件有3个参数P1、P2、P3，其中P1代表Oracle要读取的文件的绝对文件号，P2代表Oracle从这个文件中开始读取的起始数据块块号，P3代表读取的Block数量，通常这个值为1，表明是单个Block被读取。
SQL> select name,parameter1,parameter2,parameter3 from v$event_name where name='db file sequential read';
NAME PARAMETER1 PARAMETER2 PARAMETER3
------------------------------ ---------- ---------- ----------
db file sequential read file# block# blocks
如果这个等待事件比较显著，可能表示在多表连接中，表的连接顺序存在问题，可能没有正确的使用驱动表；或者可能索引的使用存在问题，并非索引总是最好的选择。
在大多数情况下，通过索引可以更为快速地获取记录，所以对于一个编码规范、调整良好的数据库，这个等待事件很大通常是正常的。但是在很多情况下，使用索引并不是最佳的选择，比如读取较大表中大量的数据，全表扫描可能会明显快于索引扫描，所以在开发中就应该注意，对于这样的查询应该避免使用索引扫描。
从Oracle 9iR2开始，Oracle引入了段级统计信息收集的新特性，收集的统计信息共有11类：
Select * from v$segstat_name;
在Oracle 10gR2中，这类统计信息增加为15个。
对于CBO模式下的数据库，应当及时收集统计信息，使SQL可以选择正确的执行计划，避免因为统计信息陈旧而导致的执行错误等。
2. Db file scattered read（数据文件离散读取）
SQL> select * from v$event_name where name='db file scattered read';
EVENT# EVENT_ID NAME PARAMETER1 PARAMETER2 PARAMETER3
---------- ---------- ------------------------- ---------- ---------- ----------
188 506183215 db file scattered read file# block# blocks
从V$EVENT_NAME视图可以看到，该事件有3个参数，分别代表文件号、起始数据块号、数据块的数量。
起始数据块号加上数据块的数量，这意味着Oracle session正在等待多块连续读操作的完成。这个操作可能与全表扫描（Full table scan）或者快速全索引扫描（Index Fast Full Scan）的连续读取相关。根据经验，通常大量的db file scattered read等待可能意味着应用问题或者索引缺失。
在实际环境的诊断过程中，可以通过v$session_wait视图发现session的等待，再结合其他视图找到存在问题的SQL等根本原因，从而从根本上解决问题。当这个等待事件比较显著时，也可结合v$session_longops动态性能视图来进行诊断，该视图记录了长时间（运行时间超过6秒的）运行的事务。
从Oracle 9i开始，Oracle新增加了一个视图V$SQL_PLAN用于记录当前系统Library Cache中SQL语句的执行计划，可以通过这个视图找到存在问题的SQL语句。
通过V$SQL_PLAN视图，可以获得大量有用的信息：
获得全表扫描的对象
Select distinct object_name,object_owner from v$sql_plan p Where p.operation='TABLE ACCESS'and p.options='FULL' and object_owner='SYS';
获得全索引扫描的对象
Select distinct object_name,object_owner from v$sql_plan p Where p.operation='INDEX' and p.options='FULL SCAN' and object_owner='SYS';
通过V$SQL_PLAN和V$SQLTEXT联合，获得全表扫描的SQL语句
Select sql_text from v$sqltext t,v$sql_plan p Where t.hash_value=p.hash_value And p.operation='TABLE ACCESS' And p.options='FULL' Order by p.hash_value,t.piece;
3. Direct path read/write（直接路径读/写）
直接路径读通常发生在Oracle直接读取数据到PGA时，这个读取不需要经过SGA。直接路径读等待事件的3个参数分别是：file#（指绝对文件号）、first block#和block数量。
这类读取通常在以下情况被使用：
磁盘排序IO操作
并行查询从属进程
预读操作
最常见的是第一种情况。在DSS系统中，存在大量的Direct path read是很正常的，但是在OLTP系统中，通常显著的直接路径读都意味着系统应用存在问题，从而导致大量的磁盘排序读取操作。
直接路径写通常发生在Oracle直接从PGA写数据到数据文件或临时文件，这个写操作可以绕过SGA。直接路径写等待事件的3个参数分别是：file#（指绝对文件号）、first block#和block数量。
这类读取通常在以下情况被使用：
直接路径加载
并行DML操作
磁盘排序
对未缓存的“LOB”段的写入，随后会记录为direct path write(lob)等待
最常见的直接路径写，多数因为磁盘排序导致。对于这一写入等待，应该找到I/O操作最为频繁的数据文件（如果有过多的排序操作，很有可能就是临时文件），分散负载，加快其写入操作。
如果系统存在过多的磁盘排序，会导致临时表空间操作频繁，对于这种情况，可以考虑为不同用户分配不同的临时表空间，使用多个临时文件，写入不同磁盘或者裸设备，从而降低竞争提高性能。
日志文件相关等待
SQL> select name from v$event_name where name like '%log%';
NAME
----------------------------------------------------------------
log switch/archive
log file sequential read
log file single write
log file parallel write
log buffer space
log file switch (checkpoint incomplete)
log file switch (archiving needed)
log file switch (clearing log file)
switch logfile command
log file switch completion
log file sync
STREAMS capture process waiting for archive log
已选择12行。
4. Log File Switch（日志文件切换）
Log File Switch当日志文件发生切换时出现，在数据库进行日志切换时，LGWR需要关闭当前日志组，切换并打开下一个日志组，在这个切换过程中，数据库的所有DML操作都处于停顿状态，直至这个切换完成。
Log File Switch主要包含两个子事件：
1. log file switch(achiving needed)，即日志切换（需要归档）
这个等待事件出现时通常是因为日志组循环写满以后，在需要覆盖先前日志时，发现日志归档尚未完成，出现该等待。由于Redo不能写出，该等待出现时，数据库将陷于停顿状态。
出现该等待，可能表示I/O存在问题、归档进程写出缓慢，也有可能是日志组设置不合理等原因导致。针对不同原因，可以考虑采用的解决方法有：
可以考虑增大日志文件和增加日志组；
移动归档文件到快速磁盘；
调整log_archive_max_processes参数等；
2. log file switch(checkpoint incomplete)，即日志切换（检查电未完成）
当所有的日志组都写满之后。LGWR试图覆盖某个日志文件，如果这时数据库没有完成写出由这个日志文件所保护的脏数据时（检查点未完成），该等待事件出现。该等待出现时，数据库同样将陷于停顿状态。
该等待事件通常表示DBWR写出速度太慢或者I/O存在问题。为解决该问题，可能需要考虑增加额外的DBWR或者增加日志组或日志文件大小。
5. Log File Sync（日志文件同步）
当一个用户提交或回滚数据时，LGWR将会话期的重做由日志缓冲区写入到重做日志中，LGWR完成任务以后会通知用户进程。日志文件同步过程（Log File Sync）必须等待这一过程成功完成。对于回滚操作，该事件记录从用户发出Rollback命令道回滚完成的时间。
如果该等待过多，可能说明LGWR的写出效率低下，或者系统提交过于频繁。针对该问题，可以通过log file parallel write等待事件或User Commits、User Rollback等统计信息来观察提交或回滚次数。
可能的解决方案主要有：
1). 提高LGWR性能，尽量使用快速磁盘，不要把redo log file存放在RAID5的磁盘上；RAID5 对于频繁写入得系统会带来较大的性能损失，可以考虑使用文件系统直接输入/输出，或者使用裸设备(raw device)，这样可以获得写入的性能提高。
2). 使用批量提交；
3). 适当使用NOLOGGING/UNRECOVERABLE等选项
6. Log File Single Write
该事件仅与写日志文件头块相关，通常发生在增加新的组成员和增进序列号（Log switch）时。头块写单个进行，因为头块的部分信息是文件号，每个文件不同。更新日志文件头这个操作在后台完成，一般很少出现等待，无需太多关注。
7. Log File Parallel Write
从Log Buffer写Redo记录到日志文件，主要指常规写操作（相对于Log File Sync）。如果Log Group存在多个组成员，当Flush Log Buffer时，写操作是并行的，这时候此等待事件可能出现。
尽管这个写操作并行处理，直到所有I/O 操作完成该写操作才会完成(如果你的磁盘支持异步IO或者使用IO SLAVE，那么即使只有一个redo log file member,也有可能出现此等待)。
这个参数和log file sync 时间相比较可以用来衡量log file 的写入成本。通常称为同步成本率。
8. Log Buffer Space（日志缓冲空间）
当数据库产生日志的速度比LGWR的写出速度快，或者当日志切换太慢时，就会发生这种等待。这个等待出现时，通常表明Redo log buffer过小，为解决这个问题，可以考虑增大日志文件的大小或者增加日志缓冲器的大小。
另一个可能的原因是磁盘I/O存在瓶颈，可以考虑使用写入速度更快的磁盘。在允许的条件下设置，可以考虑使用裸设备来存放日志文件，提高写入效率。在一般的系统中，最低的标准是，不要把日志文件和数据文件存放在一起，因为通常日志文件只写不读，分离存放可以获得性能提升，尽量使用RAID10而不是RAID5磁盘来存储日志文件。
9. Enqueue(队列等待)
Enqueue是一种保护共享资源的锁定机制。该锁定机制保护共享资源，以避免因并发操作而损坏数据，比如通过锁定保护一行记录，避免多个用户同时更新。Enqueue采用排队机制，即FIFO(先进先出)来控制资源的使用。
Enqueue是一组锁定事件的集合，如果数据库中这个等待事件比较显著，还需要进一步追踪是哪一个类别的锁定引发了数据库等待。
SQL> select name,wait_class from v$event_name where name like '%enq%' and rownum<11;
--这里记录很多 只去取出了前10条而已
NAME WAIT_CLASS
------------------------- ------------------------------------------------------
enq: PW - flush prewarm b Application
enq: RO - contention Application
enq: RO - fast object reu Application
enq: KO - fast object che Application
enq: MV - datafile move Administrative
enq: TM - contention Application
enq: ST - contention Configuration
enq: TX - row lock conten Application
enq: TX - allocate ITL en Configuration
enq: TX - index contentio Concurrency
已选择10行。
10. Latch Free(闩锁释放)
Latch Free通常被称为闩锁释放，这个名称常常引起误解，实际上应该在前面加上一个”等待(WAIT)”，当数据库出现这个等待时，说明有进程正在等待某个Latch被释放，也就是Waiting Latch Free。
Latch是一种低级排队(串行)机制，用于保护SGA中共享内存结构。Latch就像是一种快速的被获取和释放的内存锁，用于防止共享内存结构被多个用户同时访问。
如果latch不可用，就会记录latch释放失败(latch free miss )。有两种与闩有关的类型:
1) 立刻。
2) 可以等待。
假如一个进程试图在立刻模式下获得闩，而该闩已经被另外一个进程所持有，如果该闩不能立可用的话，那么该进程就不会为获得该闩而等待。它将继续执行另一个操作。
大多数latch问题都与以下操作相关:
没有很好的是用绑定变量(library cache latch)、重作生成问题(redo allocation latch)、缓冲存储竞争问题(cache buffers LRU chain)，以及buffer cache中的存在"热点"块(cache buffers chain)。
通常我们说，如果想设计一个失败的系统，不考虑绑定变量，这一个条件就够了，对于异构性强的系统，不使用绑定变量的后果是极其严重的。
另外也有一些latch等待与bug有关，应当关注Metalink相关bug的公布及补丁的发布。当latch miss ratios大于0.5%时，就应当研究这一问题。
Oracle的latch机制是竞争，其处理类似于网络里的CSMA/CD，所有用户进程争夺latch， 对于愿意等待类型(willing-to-wait)的latch,如果一个进程在第一次尝试中没有获得latch,那么它会等待并且再尝试一次,如果经过_spin_count次争夺不能获得latch, 然后该进程转入睡眠状态，持续一段指定长度的时间，然后再次醒来，按顺序重复以前的步骤.在8i/9i中默认值是_spin_count=2000。
如果SQL语句不能调整，在8.1.6版本以上，Oracle提供了一个新的初始化参数: CURSOR_SHARING可以通过设置CURSOR_SHARING = force 在服务器端强制绑定变量。设置该参数可能会带来一定的副作用，对于Java的程序，有相关的bug，具体应用应该关注Metalink的bug公告。
11. Free Buffer-释放缓冲区
这个等待事件表明系统正在等待内存中的可用空间，这说明当前Buffer 中已经没有Free 的内存空间。如果应用设计良好，SQL 书写规范，充分绑定变量，那这种等待可能说明Buffer Cache 设置的偏小，你可能需要增大DB_BUFFER_CACHE。
Free Buffer 等待可能说明DBWR 的写出速度不够，或者磁盘存在严重的竞争，可以需要考虑增加检查点、使用更多的DBWR 进程，或者增加物理磁盘的数量,分散负载，平衡IO。
12. Buffer Busy-缓冲区忙
该等待事件表示正在等待一个以unshareable方式使用的缓冲区，或者表示当前正在被读入buffer cache。一般来说Buffer Busy Wait不应大于1%。检查缓冲等待统计部分(或V$WAITSTAT)，看一下等待是否位于段头(Segment Header)。如果是，可以考虑增加自由列表(freelist，对于Oracle8i DMT)或者增加freelist groups(在很多时候这个调整是立竿见影的，在8.1.6之前，这个freelists参数不能动态修改;在8.1.6及以后版本，动态修改feelists需要设置COMPATIBLE至少为8.1.6).
如果这一等待位于undo header，可以通过增加回滚段(rollback segment)来解决缓冲区的问题。如果等待位于undo block上，我们可能需要检查相关应用，适当减少大规模的一致性读取，或者降低一致性读取(consistent read)的表中的数据密度或者增大DB_CACHE_SIZE。
如果等待处于data block，可以考虑将频繁并发访问的表或数据移到另一数据块或者进行更大范围的分布(可以增加pctfree值 ，扩大数据分布，减少竞争)，以避开这个"热点"数据块，或者可以考虑增加表中的自由列表或使用本地化管理的表空间(Locally Managed Tablespaces)。
如果等待处于索引块，应该考虑重建索引、分割索引或使用反向键索引。为了防止与数据块相关的缓冲忙等待，也可以使用较小的块:在这种情况下，单个块中的记录就较少，所以这个块就不是那么"繁忙";或者可以设置更大的pctfree,使数据扩大物理分布，减少记录间的热点竞争。
在执行DML (insert/update/ delete)时，Oracle向数据块中写入信息，对于多事务并发访问的数据表，关于ITL的竞争和等待可能出现，为了减少这个等待，可以增加initrans，使用多个ITL槽。在Oracle9i 中，引入了一个新概念:ASSM(Segment Space Management Auto)。通过这个新特性Oracle 使用位图来管理空间使用。
ASSM 结合LMT 彻底改变了Oracle 的存储机制，位图freelist 能够减轻缓冲区忙等待(buffer busy wait)，这个问题在Oracle9i 以前的版本里曾是一个严重的问题。
Oracle 宣称ASSM 显著地提高了DML 并发操作的性能，因为(同一个)位图的不同部分可以被同时使用，这样就消除了寻找剩余空间的串行化。根据Oracle 的测试结果，使用位图freelist 会消除所有分段头部(对资源)的争夺，还能获得超快的并发插入操作。在Oracle9i 之中，Buffer Busy wait 不再常见!
13. control file parallel write-控制文件并行写
当server 进程更新所有控制文件时，这个事件可能出现。如果等待很短，可以不用考虑。如果等待时间较长，检查存放控制文件的物理磁盘I/O 是否存在瓶颈。
多个控制文件是完全相同的拷贝，用于镜像以提高安全性。对于业务系统，多个控制文件应该存放在不同的磁盘上，一般来说三个是足够的，如果只有两个物理硬盘，那么两个控制文件也是可以接受的。在同一个磁盘上保存多个控制文件是不具备实际意义的。减少这个等待，可以考虑如下方法:
减少控制文件的个数(在确保安全的前提下)
如果系统支持，使用异步IO
转移控制文件到IO 负担轻的物理磁盘
14. control file sequential read/ control file single write 控制文件连续读/控制文件单个写对单个控制文件I/O 存在问题时，这两个事件会出现。如果等待比较明显，检查单个控制文件，看存放位置是否存在I/O 瓶颈。
15. direct path write-直接路径写该等待发生在，系统等待确认所有未完成的异步I/O 都已写入磁盘。
对于这一写入等待，我们应该找到I/O 操作最为频繁的数据文件(如果有过多的排序操作，很有可能就是临时文件)，分散负载，加快其写入操作。
如果系统存在过多的磁盘排序，会导致临时表空间操作频繁，对于这种情况，可以考虑使用Local管理表空间，分成多个小文件，写入不同磁盘或者裸设备。
16. Idle Event-空闲事件
一般来说，空闲等待是指系统因为无事可做的等待，或者等待用户的请求或响应等，通常我们可以忽略这些等待事件。空闲事件可以通过stats$idle_event 表查询得到。
我们看一下系统的主要空闲等待事件，对这些事件大家应该有个大致的印象，如果你的Top 5 等待事件中，主要都是这些事件，那么一般来说你的系统是比价清闲的。
注： 整理自网络
扫一扫
1686
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
