|
课程目标： - 数据库的主要组件
- 内存结构
- 后台进程
- 逻辑和物理存储结构
- ASM存储组件
1、Oracle数据库服务器的体系结构 Oracle数据库服务器包含2部分： 我们经常说的Oracle数据库，广义的说，就是包括实例部分和物理存储部分，狭义的说，就只是物理存储部分。但是对于Oracle来说，他的物理存储部分就叫数据库，管理部分叫实例，2个合起来叫数据库服务器（Database Server）。 那么客户端如何去访问数据库服务器呢，是通过客户端的用户进程把请求交给数据库服务器的服务器进程，由服务器进程来负责处理请求，也就是说客户端无法直接去修改数据库的东西，真正修改是通过数据库服务器上面的服务器进程来进行处理的。
Oracle把数据库和实例分开，就形成了以下2种的组合。 - 第一种是非集群的环境，在一台服务器上面创建多个实例和多个数据库，但是一个实例只能对应一个数据库。
- 第二种是集群的环境，将实例放在多个服务器上面，而将数据库放在共享存储上面，多个实例对应一个数据库，任何一个实例所在的服务器（称之为节点）宕机，都不影响整个系统，而且任何实例对共享存储的修改，在其他实例都可以看得到，提供了一个高可用的解决方案。集群系统一般有2种实现方式，一种是Oracle的RAC（Real Application Cluster），一种是第三方的HA（High Availability），在Oracle的RAC出现之后，第三方的HA用得越来越少了。目前一般都是使用Oracle的RAC部署集群。
数据库创建好后，客户端要去访问数据库，这里就涉及到2个概念。 - 连接（connection），就是客户端的用户进程和服务器端的实例之间的通信路径。如果用户进程和实例在同一主机上面，使用内部进程来创建连接，如果用户进程和实例在不同主机上面，则使用网络来创建连接。
- 会话（session），就是用户登录到数据库实例的一种状态，或者说是通信双方从开始通信到通信结束期间的一个上下文（Context）。这个上下文是一段位于服务器端的内存：记录了本次连接的客户端机器、通过哪个应用程序、哪个用户登录等信息。例如使用用户名和密码通过SQLPLUS登录到数据库实例，就是创建了一个会话。是专属于某一个用户的特定的连接。
会话是和连接是同时建立的，两者是对同一件事情不同层次的描述。简单讲，连接是物理上的客户端同服务 器的通信链路，会话是逻辑上的用户同服务器的通信交互。在一条连接上可以建立0个、一个或多个会话。各个会话是单独而且独立的，即使它们共享同一条数据库物理连接也是如此。一个会话中的提交不会影响该连接上的任何其他会话。 一个连接对应一个会话的示意图如下：
一个连接对应两个会话的示意图如下：
可以通过动态性能视图v$session去查询会话的信息。 例子：通过设置autotrace，在同一个连接下新增加一个会话 SQL> select sid,serial#,paddr from v$session where username='SYS'; SID SERIAL# PADDR ---------- ---------- ---------------- 39 1021 00000000917A8D40 SQL> set autotrace on statistics; SQL> select sid,serial#,paddr from v$session where username='SYS'; SID SERIAL# PADDR ---------- ---------- ---------------- 29 921 00000000917A8D40 39 1021 00000000917A8D40 例子：结束所有会话但是不断开连接 SQL> disconnect Disconnected from Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production With the Partitioning, OLAP, Data Mining and Real Application Testing options 例子：查看会话详细信息 SQL> conn / as sysdba Connected. SQL> desc v$session; SQL> select sid,serial#,username,program from v$session; SID SERIAL# USERNAME PROGRAM ---------- ---------- ---------- ---------------------------------------- 21 403 SYS sqlplus@oracletest1 (TNS V1-V3) 其中： SID为Session identifier，会话标识符 Serial#为Session serial number，会话序列号 Oracle内部进程的USERNAME为空
需要使用SID和Serial#共同确定唯一的session，例如我们在会话里面再使用conn / as sysdba发起新的session，此时session的sid不变，但是serial#会改变。 SQL> conn / as sysdba Connected. SQL> select sid,serial#,username,program from v$session; SID SERIAL# USERNAME PROGRAM ---------- ---------- ---------- ---------------------------------------- 21 405 SYS sqlplus@oracletest1 (TNS V1-V3) 可以看到session被应用于Oracle层次而非操作系统层次。同时sessions也是Oracle中一个参数，在不考虑通过专用服务器或共享服务器进行登录的情况下，这个参数限制了对指定实例的并发登陆数。 例子：查看参数sessions的值 SQL> show parameter sessions NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ sessions integer 247 我们在创建数据库的时候会指定一个服务器进程Processes参数，这个参数限制了连接到实例的操作系统进程数量。
例子：查看参数processes的值 SQL> show parameter processes; NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ processes integer 150 那么这个参数和session有什么关系呢？如果数据库运行在专用服务器模式（Dedicated），一个会话对应一个服务器进程，如果数据库运行在共享服务器模式（Shared），一个服务器进程可以为多个会话服务。 例子：查询数据库运行在哪种服务器方式 SQL> select distinct server from v$session; SERVER --------- DEDICATED 可以通过动态性能视图v$process去查询进程的信息 例子：通过v$session和v$process视图看会话和进程的关系 SQL> select s.sid,s.username,p.spid,p.username from v$session s join v$process p on s.paddr=p.addr where s.username is not null; SID USERNAME SPID USERNAME ---------- ---------- ---------- ---------- 46 SYS 10844 oracle 38 SYS 11445 oracle 37 HR 11495 oracle 45 SYS 11178 oracle Oracle的sessions和processes的数量关系是： sessions=(1.1 * processes) + 5 sessions=(1.5 * processes) + 22 例子：查看当前数据库版本 SQL> select * from v$version; BANNER -------------------------------------------------------------------------------- Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production PL/SQL Release 11.2.0.4.0 - Production CORE 11.2.0.4.0 Production TNS for Linux: Version 11.2.0.4.0 - Production NLSRTL Version 11.2.0.4.0 - Production 可以看到当前版本为11g R2，前面查询到的sessions数量为247，processes数量为150，则刚好满足公式： 247=（1.5*150）+22。 如果你碰到了ORA-12516错误，一般都是超过了Oracle的会话数限制，但是Oracle的最大会话数是由初始化参数processes控制的，并不是由参数sessions控制的，设置processes后系统通过上面的公式自动计算sessions的值。 例子：查看系统曾经最大会话数量，如果接近最大值，则增大processes SQL> select * from v$resource_limit where resource_name = 'sessions'; RESOURCE_NAME CURRENT_UTILIZATION MAX_UTILIZATION INITIAL_ALLOCATION LIMIT_VALUE -------------------- ------------------- --------------- -------------------- -------------------- sessions 45 69 247 247 所有会话曾经达到的最大值为69，包含内部进程的会话。 如果要这个最大值接近247，则增加processes。 例子：增大processes为300 SQL> alter system set processes=300 scope=spfile; System altered. 需要重启数据库 SQL> shutdown immediate; Database closed. Database dismounted. ORACLE instance shut down. SQL> startup ORACLE instance started. Total System Global Area 835104768 bytes Fixed Size 2257840 bytes Variable Size 549456976 bytes Database Buffers 281018368 bytes Redo Buffers 2371584 bytes Database mounted. Database opened. 查看确认，已经更改了。 SQL> show parameter processes NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ processes integer 300 SQL> show parameter sessions NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ sessions integer 472 v$session视图的status字段表示会话的状态，会话有ACTIVE、INACTIVE、KILLED、CACHED、SNIPED五个状态，一般比较常见的是ACTIVE、INACTIVE、KILLED这三个状态。 - ACTIVE：处于此状态的会话，表示正在执行，处于活动状态。
- INACTIVE：处于此状态的会话表示不是正在执行的
- KILLED：处于此状态的会话，表示出现了错误或进程被杀掉，正在回滚，也占用系统资源
- CACHED： Session temporarily cached for use by Oracle*XA
- SNIPED： Session inactive, waiting on the client，标记为SNIPED的进程被释放有两种条件：
（1）相关的terminal再一次试图登录及执行sql （2）手动的在操作系统后台kill掉相应的spid 例子：查看会话的状态 SQL> select sid,serial#,username,program,status from v$session; SID SERIAL# USERNAME PROGRAM STATUS ---------- ---------- ---------- ---------------------------------------- -------- 1 5 SYS sqlplus@oracletest1 (TNS V1-V3) INACTIVE 2 1 oracle@oracletest1 (PMON) ACTIVE 如果某个用户的会话无响应，可以手工结束他 例子：结束某个用户的会话 SQL> select sid,serial#,username,program,status from v$session where username is not null; SID SERIAL# USERNAME PROGRAM STATUS ---------- ---------- ---------- ---------------------------------------- -------- 1 5 SYS sqlplus@oracletest1 (TNS V1-V3) INACTIVE 45 51 HR sqlplus@oracletest1 (TNS V1-V3) INACTIVE 46 65 SYS sqlplus@oracletest1 (TNS V1-V3) ACTIVE SQL> alter system kill session '45,51' immediate; System altered. SQL> select sid,serial#,username,program,status from v$session where username is not null; SID SERIAL# USERNAME PROGRAM STATUS ---------- ---------- ---------- ---------------------------------------- -------- 1 5 SYS sqlplus@oracletest1 (TNS V1-V3) INACTIVE 46 65 SYS sqlplus@oracletest1 (TNS V1-V3) ACTIVE
2、数据库内存结构 前面说了，Oracle数据库服务器包括实例和数据库。客户端发出的SQL命令由服务器进程响应，在内存区域内进行语法分析、编译和执行，将修改信息写入日志文件，再将修改后的数据写入数据文件，最后将SQL执行的结果反馈给用户。不同的操作系统以及数据库的配置，会有不同的内存结构，这里我们的数据库主要运行在Linux下，主要学习Linux下的Oracle的内存结构，暂不去讨论Windows的内存结构。
实例又由内存和后台进程组成
我们先来看内存结构，如下图：
内存结构又主要分为2个部分： - System Global Area (SGA)：包含数据和控制信息的共享内存区域。这句话可以说是SGA的定义。虽然简单，但其中阐述了SGA几个很重要的特性：1、SGA的构成——数据和控制信息；2、SGA是共享的，即当有多个用户同时登录了这个实例，SGA中的信息可以被它们同时访问；3、一个SGA只服务于一个实例，也就是说，当一台机器上有多个实例运行时，每个实例都有一个自己的SGA，尽管SGA来自于OS的共享内存区，但实例之间不能相互访问对方的SGA区。
- Program Global Areas (PGA)：包含一个服务器进程或者后台进程的数据和控制信息的私有内存区域。它是Oracle在一个服务器进程或者后台进程启动时创建的非共享内存，一个PGA也只能被拥有它的那个服务器进程所访问。PGA的总和成为instance PGA。
System Global Area (SGA)主要由以下部分组成： - 共享池（Shared Pool）
- 数据库缓冲区缓存（Buffer Cache）
- 重做日志缓冲（Redo Log Buffer）
- 大池（Large Pool）
- Java池（Java Pool）
- 流池（Streams Pool）
（1）共享池（Shared Pool）
共享池（Shared Pool）由库缓存（Library Cache）、数据字典缓存（Data Dictionary Cache）、SQL查询结果及PL/SQL函数结果缓存、并行执行消息的缓冲以及控制结构组成。在Oracle 11g中，Shared Pool的大小建议由系统自动管理。 例子：查看共享池的大小 SQL> select name,bytes/1024/1024 from v$sgainfo where name='Shared Pool Size'; NAME BYTES/1024/1024 -------------------------------- --------------- Shared Pool Size 168 库缓存（Library Cache） Library Cache是用于存储可执行的SQL和PL/SQL代码的共享池内存结构，包括共享的SQL和PL/SQL区域以及控制结构（如锁、库缓存句柄）。用于解析SQL语句，解析和编译PL/SQL程序，生成SQL执行计划。如果是共享服务模式，那么库缓存还包括私有SQL区域。 当执行一个SQL语句，如果该SQL语句的解析已经存在于库缓存且可以被共享，则数据库直接使用已有的解析，我们称之为软解析或者库缓存命中，否则就需要创建一个新的解析，我们称之为硬解析或者库缓存命中失败。 共享SQL区和私有SQL区
Oracle会为每一条SQL语句运行提供一个共享SQL区（Shared SQL Areas）和私有SQL区（专用模式下Private SQL Areas属于PGA）。 一个共享SQL区中保存了一条语句的解析树和查询计划。当发现两个（或多个）用户都在运行同一SQL语句时，Oracle会重新组织SQL区，使这些用户能重用共享SQL区。但还会在私有SQL区中保存一份这条SQL语句的拷贝。 就是说执行SQL语句的每一个会话在他的PGA里面都有一个私有SQL区，执行同一SQL语句的用户的私有SQL区都指向同一个共享SQL区，因此，在不同PGA里面的私有SQL区可以关联同一个共享SQL区。在多用户系统中，Oracle通过为SQL语句使用同一共享SQL区多次运行来节省内存。 当一条新的SQL语句被解析时，Oracle从共享池中分配一块内存作为共享SQL区。这块内存的大小与这条语句的复杂性相关。如果Shared Pool没有足够空间分配给共享SQL区，Oracle将释放从LRU（Least Recently Used）链表中查找到最近最少使用的内存块，直到有足够空间给新的语句的共享SQL区。如果Oracle释放的是一个共享SQL区的内存，那么相应的语句在下次执行时需要再次解析并重新分配共享SQL区。而从解析语句到分配共享SQL区是一个比较消耗CPU的工程。这就是为什么我们提倡使用绑定变量的原因了。在没有使用绑定变量时，语句中的变量的数值不同，oracle就视为一条新的语句（9i后可以通过cursor_sharing来控制），重复上面的解析、内存分配的动作，将大大消耗系统资源，降低系统性能。 数据字典缓存（Data Dictionary Cache） 数据字典是有关于数据库的参考信息、数据库的结构信息和数据库中的用户信息的一组表和视图的集合，如我们常用到的V$视图、DBA_视图都属于数据字典。在SQL语句解析的过程中，Oracle频繁的访问（如果需要的话）这些数据字典，因此内存中有两处地方被专门用于存放数据字典。一个地方就是数据字典缓存（Data Dictionary Cache）。数据字典缓存也被称为行缓存（Row Cache），因为它是以记录行为单元存储数据的，而不像Buffer Cache是以数据块为单元存储数据。内存中另外一个存储数据字典的地方是库缓存。所有Oracle的用户都可以访问这两个地方以获取数据字典信息。 在SQL Trace中，这种对数据字典的访问就被统计为回调（recursive calls）。 例子：查看SQL语句执行的回调信息 SQL> set linesize 150 SQL> set autotrace traceonly SQL> select * from hr.employees; 107 rows selected. Execution Plan ---------------------------------------------------------- Plan hash value: 1445457117 ------------------------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Time | ------------------------------------------------------------------------------- | 0 | SELECT STATEMENT | | 107 | 7383 | 3 (0)| 00:00:01 | | 1 | TABLE ACCESS FULL| EMPLOYEES | 107 | 7383 | 3 (0)| 00:00:01 | ------------------------------------------------------------------------------- Statistics ---------------------------------------------------------- 149 recursive calls 0 db block gets 245 consistent gets 17 physical reads 0 redo size 10427 bytes sent via SQL*Net to client 596 bytes received via SQL*Net from client 9 SQL*Net roundtrips to/from client 9 sorts (memory) 0 sorts (disk) 107 rows processed SQL> select * from hr.employees; 107 rows selected. Execution Plan ---------------------------------------------------------- Plan hash value: 1445457117 ------------------------------------------------------------------------------- | Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Time | ------------------------------------------------------------------------------- | 0 | SELECT STATEMENT | | 107 | 7383 | 3 (0)| 00:00:01 | | 1 | TABLE ACCESS FULL| EMPLOYEES | 107 | 7383 | 3 (0)| 00:00:01 | ------------------------------------------------------------------------------- Statistics ---------------------------------------------------------- 0 recursive calls 0 db block gets 14 consistent gets 0 physical reads 0 redo size 10427 bytes sent via SQL*Net to client 596 bytes received via SQL*Net from client 9 SQL*Net roundtrips to/from client 0 sorts (memory) 0 sorts (disk) 107 rows processed 服务器结果缓存（Server Result Cache） 服务器结果缓存是Oracle 11g的新特性，包括SQL查询结果缓存和PL/SQL函数结果缓存，当sql执行时，数据库先去result cache查找相关结果；当结果相关的对象发生变化，例如相关表的数据被删除一条，则结果缓存失效。 保留池（Reserved Pool） 前面提到，如果Oracle解析一个 PL/SQL程序单元，也需要从共享池中分配内存给这些程序单元对象。由于这些对象本一般比较大（如包），所以分配的内存空间也相对较大。系统经过长时间运行后，共享池可能存在大量内存碎片，导致无法满足对于大块内存段的分配。 为了使有足够空间缓存大程序块，Oracle专门从共享池分配一块内存保存这些大块。这个保留池的默认大小是共享池的5%。它的大小也可以通过参数SHARED_POOL_RESERVED_SIZE来调整。保留池是从共享池中分配，不是直接从SGA中分配的，它是共享池的保留部分，用于存储大块段。 Shared Pool中内存大于5000字节的大段就会被存放在共享池的保留部分。而这个大小限制是通过隐含参数_SHARED_POOL_RESERVED_MIN_ALLOC来设定的（如前面所说，隐含参数不要去修改它）。除了在实例启动过程中，所有小于这个数的内存段永远都不会放到保留部分中，而大于这个值的大内存段也永远不会存放到非保留池中，即使共享池的空间不够用的情况下也是如此。 保留池的空闲内存也不会被包含在普通共享池的空闲列表中。它会维护一个单独的空闲列表。保留池也不会在它的LRU列表中存放可重建段。当释放普通共享池空闲列表上的内存时是不会清除这些大段的，同样，在释放保留池的空闲列表上的大内存段时也不会清除普通共享池中内存。 通过视图V$SHARED_POOL_RESERVED可以查到保留池的统计信息。其中字段REQUEST_MISSES记录了没有立即从空闲列表中得到可用的大内存段请求次数，这个值要为0。因为保留池必须要有足够个空闲内存来适应那些短期的内存请求，而无需将那些需要长期cache住的没被pin住的可重建的段清除。否则就需要考虑增大SHARED_POOL_RESERVED_SIZE了。 你可以通过观察视图V$SHARED_POOL_RESERVED的MAX_USED_SIZE字段来判断保留池的大小是否合适。大多数情况下，你会观察到保留池是很少被使用的，也就是说5%的保留池空间可能有些浪费。但这需要经过长期观察来决定是否需要调整保留池大小。 例子：查看参数SHARED_POOL_RESERVED_SIZE SQL> show parameter SHARED_POOL_RESERVED_SIZE NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ shared_pool_reserved_size big integer 6M 例子：查看共享池的保留池中，没有立即从空闲列表中得到可用的大内存段请求次数 SQL> select request_misses from v$shared_pool_reserved; REQUEST_MISSES -------------- 0 共享池的内存管理 通常来说，共享池是根据修正过的LRU算法来释放其中的对象（共享SQL区和数据自动记录行）的，否则这些对象就一直保持在共享池中。如果共享池需要为一个新对象分配内存，并且共享池中没有足够内存时，内存中那些不经常使用的对象就被释放掉。一个被许多会话使用过的共享池对象，即使最初创建它的进程已经结束，只要它是有用的，都会被修正过的LRU算法一直保持在共享池中。这样就使一个多用户的Oracle系统对SQL语句的处理和内存消耗最小。 当一条SQL语句被提交给Oracle执行，Oracle会自动执行以下的内存分配步骤： - Oracle检查共享池，看是否已经存在关于这条语句的共享SQL区。如果存在，这个共享SQL区就被用于执行这条语句。而如果不存在，Oracle就从共享池中分配一块新的共享SQL区给这条语句。同时，无论共享SQL区存在与否，Oracle都会为用户分配一块私有SQL区以保存这条语句相关信息（如变量值）。
- Oracle为会话分配一个私有SQL区。私有SQL区的所在与会话的连接方式相关。
在以下情况下，Oracle也会将共享SQL区从共享池中释放出来： - 当使用ANALYZE语句更新或删除表、簇或索引的统计信息时，所有与被分析对象相关的共享SQL区都被从共享池中释放掉。当下一次被释放掉的语句被执行时，又重新在一个新的共享SQL区中根据被更新过的统计信息重新解析
- 当对象结构被修改过后，与该对象相关的所有共享SQL区都被标识为无效（invalid）。在下一次运行语句时再重新解析语句
- 如果数据库的全局数据库名（Global Database Name）被修改了，共享池中的所有信息都会被清空掉
- DBA通过ALTER SYSTEM FLUSH SHARED_POOL手工方式清空共享池
例子：手动清空共享池 SQL> alter system flush shared_pool; System altered. （2）数据库缓冲区缓存（Database Buffer Cache）
Database Buffer Cache也叫Buffer Cache，是SGA区中专门用于存放从数据文件中读取的的数据块拷贝的区域。Oracle进程如果发现需要访问的数据块已经在Buffer Cache中，就直接读写内存中的相应区域，而无需读取数据文件，从而大大提高性能。Buffer Cache对于所有Oracle进程都是共享的，能被所有Oracle用户访问。在Oracle 11g中，Database Buffer Cache的大小建议由系统自动管理。 例子：查看数据库缓冲区缓存的大小 SQL> select name,bytes/1024/1024 from v$sgainfo where name='Buffer Cache Size'; NAME BYTES/1024/1024 -------------------------------- --------------- Buffer Cache Size 332 Buffer有三种状态： - Unused：没有被使用的Buffer，数据库优先使用
- Clean：已经被使用过但包含的是clean的数据，就是目前和磁盘上的数据一致，可以重复使用
- Dirty：包含的是修改后数据，但是还没有写入到磁盘，与磁盘上面的数据不一致
Buffer有两种访问模式： - Current mode：指当前用户访问当前修改后未提交事务的数据，获取的就是当前Buffer Cache里面的数据块
- Consistent mode：指其他用户访问当前用户修改后未提交事务的数据，获取的是undo里面的读一致性的数据块
Oracle对于buffer cache的管理，是通过两个重要的链表实现的：写链表和最近最少使用链表（the Least Recently Used LRU）。写链表所指向的是所有脏数据块缓存。而LRU链表指向的是所有空闲的缓存、pin住的缓存以及还没有来的及移入写链表的脏缓存。空闲缓存中没有任何有用的数据，随时可以使用。而pin住的缓存是当前正在被访问的缓存。LRU链表的两端就分别叫做最近使用端（the Most Recently Used MRU）和最近最少使用端（LRU）。 当一个Oracle进程访问一个缓存时，这个进程会将这块缓存移到LRU链表中的MRU。而当越来越多的缓冲块被移到MRU端，那些已经过时的脏缓冲（即数据改动已经被写入数据文件中，此时缓冲中的数据和数据文件中的数据已经一致）则被移到LRU链表中LRU端。 当一个Oracle用户进程第一次访问一个数据块时，它会先查找buffer cache中是否存在这个数据块的拷贝。如果发现这个数据块已经存在于buffer cache（即命中cache hit），它就直接读从内存中取该数据块。如果在buffer cache中没有发现该数据块（即未命中cache miss），它就需要先从数据文件中读取该数据块到buffer cache中，然后才访问该数据块。命中次数与进程读取次数之比就是我们一个衡量数据库性能的重要指标：buffer hit ratio（buffer命中率）。 例子：获得自实例启动至今的buffer命中率 SQL> select 1-(sum(decode(name,'physical reads',value,0))/ 2 (sum(decode(name,'db block gets',value,0))+ 3 (sum(decode(name,'consistent gets',value,0))))) "Buffer Hit Ration" 4 from v$sysstat; Buffer Hit Ration ----------------- .984403316 根据经验，一个良好性能的系统，这个值一般保持在95%以上。 上面提到如果未命中（missed），则需要先将数据块读取到缓存中去。这时Oracle进程需要从空闲列表 中找到一个适合大小的空闲buffer。如果空闲列表中没有适合大小的空闲buffer，它就会从LRU端开始查找LRU链表，直到找到一个可重用的缓存块或者达到最大查找块数限制。在查找过程中，如果进程找到一个脏缓存块，它将这个缓存块移到写链表中去，然后继续查找。当它找到一个空闲块后，就从磁盘中读取数据块到缓存块中，并将这个缓存块移到LRU链表的MRU端。 当有新的对象需要请求分配buffer时，会通过内存管理模块请求分配空闲的或者可重用的buffer。“free buffer requested”就是产生这种请求的次数；当请求分配buffer时，已经没有适合大小的空闲buffer时，需要从LRU链表上获取到可重用的buffer。但是LRU链表上的buffer并非都是立即可重用的，还会存在一些块正在被读写或者已经被别的用户所等待。根据LRU算法，查找可重用的buffer是从链表的LRU端开始查找的，如果这一段的前面存在这种不能立即被重用的buffer，则需要跳过去，查找链表中的下一个buffer。“free buffer inspected”就是被跳过去的buffer的数目。 例子：查看系统目前free buffer requested和free buffer inspected的值 SQL> select name,value from v$sysstat where name in ('free buffer requested','free buffer inspected'); NAME VALUE ---------------------------------------------------------------- ---------- free buffer requested 39220 free buffer inspected 0 如果Oracle用户进程达到查找块数限制后还没有找到空闲缓存，它就停止查找LRU链表，并且通过信号通知DBW0进程将脏缓存写入磁盘去。 由于Buffer Cache中存放的是从数据文件中来的数据块的拷贝，因此它的大小的计算也是以块的尺寸为基数的。而数据块的大小是由参数db_block_size指定的。9i以后，块的大小默认是8K，它的值一般设置为和操作系统的块尺寸相同或者它的倍数。每次读多少块是由参数db_file_multiblock_read_count来控制的，在Oracle10gR2以前的版本中，DBA必须根据db_block_size参数，以及应用系统的特性，来调整db_file_multiblock_read_count参数。在Oracle10gR2及其之后的版本中，Oracle数据库已经可以根据系统的IO能力以及Buffer Cache的大小来动态调整该参数值，Oracle建议不要显式设置该参数值。 例子：查看参数db_block_size SQL> show parameter db_block_size NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ db_block_size integer 8192 从9i开始，Oracle支持创建不同块尺寸的表空间，并且可以为不同块尺寸的数据块指定不同大小的buffer cache。9i以后，除了SYSTEM表空间和TEMPORARY表空间必须使用标准块尺寸外，所有其他表空间都可以最多指定四种不同的块尺寸。而标准块尺寸还是由上面的所说的参数db_block_size来指定。而db_cache_size则是标准块尺寸的buffer cache的大小。 非标准块尺寸的块大小可以在创建表空间（CREATE TABLESPACE）时通过BLOCKSIZE参数指定。而不同块尺寸的buffer cache的大小就由相应参数DB_nK_CACHE_SZIE来指定，其中n可以是2，4，8，16或者32。需要先设置DB_nK_CACHE_SIZE来指定缓存这个表空间数据块的buffer cache的大小，然后才能创建了一个块大小为nK的非标准块尺寸的表空间。 任何一个尺寸的Buffer Cache都是不可以缓存其他尺寸的数据块的。因此如果你打算使用多种块尺寸用于你的数据库的存储，你需要给你要用到的非标准块尺寸的数据块指定相应的Buffer Cache大小。这些参数使你可以为系统指定多达4种不同块尺寸的Buffer Cache。 特别注意，DB_nK_CACHE_SIZE 参数不能设定标准块尺寸的缓冲区大小。举例来说，如果 DB_BLOCK_SIZE 设定为 4K，就不能再设定 DB_4K_CACHE_SIZE 参数。 例子：是否可以设置设置db_8k_cache_size大小 SQL> alter system set db_8k_cache_size=200m scope=both; alter system set db_8k_cache_size=200m scope=both * ERROR at line 1: ORA-32017: failure in updating SPFILE ORA-00380: cannot specify db_8k_cache_size since 8K is the standard block size 例子：创建一个非标准块的表空间，假定块大小为16k 先查看DB_nK_CACHE_SZIE参数，为0表示还没有启用 SQL> show parameter db_16k_cache_size NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ db_16k_cache_size big integer 0 直接创建表空间会报错 SQL> create tablespace ts01 datafile '+DATA/stone/datafile/ts01.dbf' size 10m blocksize 16K; create tablespace ts01 datafile '+DATA/stone/datafile/ts01.dbf' size 10m blocksize 16K * ERROR at line 1: ORA-29339: tablespace block size 16384 does not match configured block sizes 为非标准块尺寸的数据块指定相应的Buffer Cache大小 SQL> alter system set db_16k_cache_size=1m scope=both; System altered. SQL> show parameter db_16k_cache_size NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ db_16k_cache_size big integer 4M 即使修改时指定的是1M，修改之后系统会自动给出一个最小的4M大小，这个参数受Granule Size控制。小于4M系统自动设置为4M，大于4M，就是4M的整数倍。 SQL> select * from v$sgainfo where name='Granule Size'; NAME BYTES RES -------------------------------- ---------- --- Granule Size 4194304 No 然后再来创建表空间就可以了 SQL> create tablespace ts01 datafile '+DATA/stone/datafile/ts01.dbf' size 10m blocksize 16k; Tablespace created. 可以将database buffer cache分成不同的buffer pool，达到不同的cache数据的目的。有以下三种： - 默认缓冲池（Default pool），块正常缓存的缓冲池，如果没有指定其他的缓冲池，那database buffer cache就是默认的缓冲池
- 保持缓冲池（Keep pool），用于缓存那些需要经常查询的对象但又容易被默认缓冲区置换出去的对象，可以更久被保留。它的大小由参数DB_KEEP_CACHE_SZIE控制
- 回收缓冲池（Recycle pool），用于缓存临时使用的、不被经常使用的较大的对象，可以更快被清除。它的大小由参数DB_RECYLE_CACHE_SIZE指定
这三个参数相互之间是独立的，并且他们都只适用于标准块尺寸的数据块。 （理论上讲，默认池中的对象应该足够热（也就是说，用得足够多），可以保证一直呆在缓存中。缓存会把它们一直留在内存中，因为它们是非常热门的块。可能还有 一些段相当热门，但是并不太热；这些块就作为温块。这些段的块可以从缓存刷新输出，为不常用的一些块（“不适合缓存”块）腾出空间。为了保持这些温段的块得到缓存，可以采取下面的某种做法：将这些段分配到保持池，力图让温块在缓冲区缓存中停留得更久。将“不适合缓存”段分配到回收池，让回收池相当小，以便块能快速地进入缓存和离开缓存（减少管理的开销）。这样会增加DBA 所要执行的管理工作，因为要考虑3 个缓存，要确定它们的大小，还要为这些缓存分配对象。还要记住，这些池之间没有共享，所以，如果保持池有大量未用的空间，即使默认池或回收池空间不够用了， 保持池也不会把未用空间交出来。总之，这些池一般被视为一种非常精细的低级调优设备，只有所有其他调优手段大多用过之后才应考虑使用。） （3）重做日志缓冲（Redo Log Buffer）
Redo Log Buffer是SGA中一段保存数据库修改信息的缓存。这些信息被存储在重做条目(Redo Entries)中。重做条目中包含了由于INSERT、UPDATE、DELETE、CREATE、ALTER或DROP所做的修改操作而需要对数据库重新组织或重做的必须信息。在必要时，重做条目还可以用于数据库恢复。 重做条目是Oracle数据库进程从用户内存中拷贝到Redo Log Buffer中去的。重做条目占用重做日志缓冲连续的空间，循环写入。后台进程LGWR负责将Redo Log Buffer中的信息写入到磁盘上联机重做日志文件。 例子：查看重做日志缓冲的大小 SQL> select name,bytes from v$sgainfo where name='Redo Buffers'; NAME BYTES -------------------------------- ---------- Redo Buffers 2371584 SQL> select name,bytes from v$sgastat where name='log_buffer'; NAME BYTES -------------------------- ---------- log_buffer 2371584 一般默认情况下的log_buffer的大小够用了，查看Log_buffer是否需要调整，可以查看数据库是否有大量的log buffer space等待事件出现。redo log 最开始是在pga中的uga产生的（数据库一般是专有模式），oracle会把它拷贝到SGA中的log_buffer中去，如果log_buffer过小，或者lgwr不能够快速将redo 写入到log file中，那么就会产生log buffer space等待事件，遇到此类问题，可以增加 log_buffer大小，调整log file到裸设备，I/O快的磁盘中。 （4）大池（Large Pool） 大池是SGA中的一块可选内存池，根据需要时配置。在以下情况下需要配置大池： - 用于共享服务（Shared Server MTS方式中）的会话内存和Oracle分布式事务处理的Oracle XA接口
- 使用并行查询（Parallel Query Option PQO）时
- IO服务进程
- Oracle备份和恢复操作（启用了RMAN时）
通过从大池中分配会话内存给共享服务、Oracle XA或并行查询，Oracle可以使用共享池主要来缓存共享SQL，以防止由于共享SQL缓存收缩导致的性能消耗。此外，为Oracle备份和恢复操作、IO服务进程和并行查询分配的内存一般都是几百K，这么大的内存段从大池比从共享池更容易分配得到。 例子：查看大池的大小 SQL> select name,bytes/1024/1024 from v$sgainfo where name='Large Pool Size'; NAME BYTES/1024/1024 -------------------------------- --------------- Large Pool Size 8 （5）Java池（Java Pool） Java池也是SGA中的一块可选内存区，它也属于SGA中的可变区。Java池的内存是用于存储所有会话中特定 Java代码和JVM中数据。Java池的使用方式依赖于Oracle服务的运行模式。不要认为使用Java开发的程序就要用Java池，只是说在数据库里面使用Java去编写了存储过程才会用到Java池，但是目前很少有人用Java去编写存储过程了。Java池的大小可以通过参数JAVA_POOL_SIZE来设置。 例子：查看Java池的大小 SQL> select name,bytes/1024/1024 from v$sgainfo where name='Java Pool Size'; NAME BYTES/1024/1024 -------------------------------- --------------- Java Pool Size 4 （6）流池（Streams Pool） 流池是Oracle 10g中新增加的。是为了增加对流（流复制是Oracle 9iR2中引入的一个非常吸引人的特性，支持异构数据库之间的复制。10g中得到了完善）的支持。但是现在Oracle的流复制技术用得很少了，因为Oracle收购了Oracle golden gate，可以跨平台，跨数据库，Oracle现在主推这个，流复制就用得越来越少了。流池也是可选内存区，属于SGA中的可变区。它的大小可以通过参数STREAMS_POOL_SIZE来指定。如果没有被指定，流池大小默认为0，Oracle会在第一次使用流时自动创建，根据需要动态增加。 例子：查看流池的大小 SQL> select name,bytes from v$sgainfo where name='Streams Pool Size'; NAME BYTES -------------------------------- ---------- Streams Pool Size 0 Shared Pool、Large Pool、Java Pool和Streams Pool这几块内存区的大小是跟随系统参数设置而改变的，所以又通称为可变SGA（Variable SGA）。 例子：查看sga的组成 SQL> select * from v$sga; NAME VALUE -------------------- ---------- Fixed Size 2257840 Variable Size 532679760 Database Buffers 297795584 Redo Buffers 2371584 SQL> show sga; Total System Global Area 835104768 bytes Fixed Size 2257840 bytes Variable Size 532679760 bytes Database Buffers 297795584 bytes Redo Buffers 2371584 bytes （7）Fixed Size Fixed Size部分为sga的固定部分，其大小由Oracle数据库设定且不可手工修改，包含: - 数据库和实例的状态信息等通用信息，后台进程需要访问这部分信息
- 进程之间的通信信息，比如锁的信息
例子：查看Fixed Size的大小 SQL> select name,bytes from v$sgainfo where name='Fixed SGA Size'; NAME BYTES -------------------------------- ---------- Fixed SGA Size 2257840
如果数据库是专用服务器模式，Program Global Areas (PGA)主要由以下部分组成： - Stack Space（堆栈空间）
- User Global Area（UGA）
其中User Global Area（UGA）包括以下部分： - Cursor State：存放游标的运行信息（可以把游标看成私有SQL区）
- User Sessions Data：存放会话的控制信息
- SQL Working Areas：处理SQL语句
其中SQL Working Areas包括以下部分： - Sort Area：使用order by或者group by排序数据时会用到这个区域
- Hash Area：表发生hash jions时会用到这个区域
- Create Bitmap Area：位图索引创建会用到这个区域
- Bitmap Merge Area：解析位图索引执行计划会用到这个区域
如果数据库是共享服务器模式，Program Global Areas (PGA)只有Stack Space，UGA在SGA里面，如果配置了大池，UGA在大池，如果没有配置大池，UGA在共享池。 例子：查看当前PGA的大小 SQL> select component,current_size/1024/1024,max_size/1024/1024 from v$memory_dynamic_components where component='PGA Target'; COMPONENT CURRENT_SIZE/1024/1024 MAX_SIZE/1024/1024 -------------------- ---------------------- ------------------ PGA Target 280 280 SQL> select name,value/1024/1024 from v$pgastat where name='aggregate PGA target parameter'; NAME VALUE/1024/1024 ---------------------------------------- --------------- aggregate PGA target parameter 280 例子：查看排序区，hash区，位图区，位图合并区的大小 SQL> show parameter sort_area_size NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ sort_area_size integer 65536 SQL> show parameter hash_area_size NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ hash_area_size integer 131072 SQL> show parameter create_bitmap_area_size NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ create_bitmap_area_size integer 8388608 SQL> show parameter bitmap_merge_area_size NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ bitmap_merge_area_size integer 1048576 例子：查看游标（私有SQL区）的数量 SQL> show parameter open_cursors NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ open_cursors integer 300 open_cursors设置一个会话可以同时打开的游标数。由于每打开一个游标，都需要一部分PGA内存分配出来作为私有SQL区。因此这个参数也影响了每个进程的PGA内存的占用大小。 例子：查看每个session 的pga内存使用 SQL> select p.username,p.spid,p.program,pm.category,pm.used,pm.allocated,pm.max_allocated 2 from v$process p join v$process_memory pm on p.pid=pm.pid 3 join v$session s on s.paddr=p.addr and s.username is not null; USERNAME SPID PROGRAM CATEGORY USED ALLOCATED MAX_ALLOCATED ---------- ---------- ------------------------------ --------------- ---------- ---------- ------------- oracle 42393 oracle@oracletest1 (TNS V1-V3) SQL 27496 40240 4892600 oracle 42393 oracle@oracletest1 (TNS V1-V3) PL/SQL 224 2008 2008 oracle 42393 oracle@oracletest1 (TNS V1-V3) Freeable 0 1048576 oracle 42393 oracle@oracletest1 (TNS V1-V3) Other 2179302 2179302 grid 42463 oracle@oracletest1 SQL 12968 89472 820392 grid 42463 oracle@oracletest1 PL/SQL 18848 25064 27352 grid 42463 oracle@oracletest1 Freeable 0 1048576 grid 42463 oracle@oracletest1 Other 2491862 2741694 grid 42469 oracle@oracletest1 SQL 152 71032 3204032 grid 42469 oracle@oracletest1 PL/SQL 43344 90696 95976 grid 42469 oracle@oracletest1 Freeable 0 524288 USERNAME SPID PROGRAM CATEGORY USED ALLOCATED MAX_ALLOCATED ---------- ---------- ------------------------------ --------------- ---------- ---------- ------------- grid 42469 oracle@oracletest1 Other 3231102 11692694 12 rows selected. 可以分成以下三步： 先从v$session获取paddr SQL> select username,sid,paddr from v$session where username is not null; USERNAME SID PADDR ------------------------------ ---------- ---------------- SYS 43 00000000917AF190 SYS 44 00000000917B0248 SYS 52 00000000917B3470 再从v$process获取对应paddr的spid SQL> select addr,pid,spid,username from v$process where addr in ('00000000917AF190','00000000917B0248','00000000917B3470'); ADDR PID SPID USERNAME ---------------- ---------- ------------------------ --------------- 00000000917AF190 35 42393 oracle 00000000917B0248 36 42463 grid 00000000917B3470 39 42469 grid 再用v$process_memory与v$process关联就可以了 SQL> select p.username,p.spid,p.program,pm.category,pm.used,pm.allocated,pm.max_allocated 2 from v$process p join v$process_memory pm on p.pid=pm.pid 3 where p.spid=42393; USERNAME SPID PROGRAM CATEGORY USED ALLOCATED MAX_ALLOCATED ---------- ---------- ------------------------------ --------------- ---------- ---------- ------------- oracle 42393 oracle@oracletest1 (TNS V1-V3) SQL 14696 27848 4892600 oracle 42393 oracle@oracletest1 (TNS V1-V3) PL/SQL 224 2008 2008 oracle 42393 oracle@oracletest1 (TNS V1-V3) Freeable 0 720896 oracle 42393 oracle@oracletest1 (TNS V1-V3) Other 2519374 2519374
3、数据库进程结构
Oracle数据库的进程分为3类： - 用户进程：运行连接到oracle数据库的应用或者工具的代码
- 数据库进程：运行Oracle数据库自己的代码，包括服务器进程及后台进程
- Oracle守护进程及应用进程：包括监听和GI的进程，这些进程不仅仅用于一个数据库
用户进程（客户端进程）用于运行连接到oracle数据库的应用或者工具的代码，当用户执行一个基于Oracle数据库的应用程序时，客户端操作系统就会创建一个用户进程。用户进程可以在数据库服务器上面，也可以不在数据库服务器上面。 服务器进程用于处理连接到该实例的用户进程的请求，主要任务包括： - 解析并执行用户所提交的SQL语句
- 搜索SGA区的数据库缓存，决定是否读取数据文件。如果数据块不在SGA区的数据库缓存中，就将其从数据文件中读入
- 将查询执行的结果数据返回给用户
例子：在客户端创建一个到数据库的连接，查看用户进程和服务器进程 C:\Users\shilei>sqlplus hr/hr@192.168.230.138:1521/stone SQL*Plus: Release 11.2.0.1.0 Production on 星期三 11月 18 08:52:00 2015 Copyright (c) 1982, 2010, Oracle. All rights reserved. 连接到: Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production With the Partitioning, OLAP, Data Mining and Real Application Testing options SQL> 查看用户进程 C:\Users\shilei>tasklist | findstr sqlplus sqlplus.exe 22764 Console 1 30,036 K 查看对应的服务器进程，其中“LOCAL=NO”表示不是本地连接，是一个远程连接 [oracle@oracletest ~]$ ps -ef | grep LOCAL=NO | grep -v grep oracle 3625 1 0 08:52 ? 00:00:00 oraclestone (LOCAL=NO) 我们在创建数据库的时候，会让你选择数据库的工作模式，是专用模式还是共享模式，不同模式下Oracle的服务器进程是不一样的，这里看一下这两种模式的区别。 Dedicated Server(专用服务器模式)：数据库为每一个用户进程分配一个服务器进程为其服务 下图表示用户通过网络连接数据库时专用服务器模式下用户进程和服务器进程之间的关系。
在专用服务器架构下，有以下两种通信机制 - 如果用户进程和专业服务器进程在一台机器上面，则使用操作系统的内部进程进行通信
- 如果用户进程和专业服务器进程在不同机器上面，则使用网络进行通信
Shared Server（共享服务器模式）：使用调度器引导网络会话请求到共享服务器进程池，使用共享服务器模式可以减少操作系统的进程数量以及PGA，但是会增大响应时间，提高安装和调优的复杂性，故目前大多数情况下都没有使用，具体实现方式就不讲了。
Oracle在实例启动的时候自动创建多个后台进程来操作管理数据库，每个后台进程都有各自的任务，可以通过v$process视图查看有哪些后台进程在运行。 例子：查看有哪些后台进程在运行 SQL> select pname from v$process where pname is not null order by pname; PNAME ----- ARC0 ARC1 ARC2 ARC3 CJQ0 CKPT D000 DBRM DBW0 DIA0 DIAG PNAME ----- GEN0 LGWR MMAN MMNL MMON PMON PSP0 Q001 Q002 QMNC RECO PNAME ----- S000 SMCO SMON VKTM W001 27 rows selected. 也可以通过操作系统查看，后台进程在操作系统上面的名称为“ora_后台进程名称_实例名称” [root@oracletest ~]# ps -ef | grep _stone | grep -v grep oracle 2436 1 0 Nov18 ? 00:00:09 ora_pmon_stone oracle 2438 1 0 Nov18 ? 00:00:16 ora_psp0_stone oracle 2440 1 2 Nov18 ? 00:24:47 ora_vktm_stone oracle 2444 1 0 Nov18 ? 00:00:02 ora_gen0_stone oracle 2446 1 0 Nov18 ? 00:00:04 ora_diag_stone oracle 2448 1 0 Nov18 ? 00:00:03 ora_dbrm_stone oracle 2450 1 0 Nov18 ? 00:00:58 ora_dia0_stone oracle 2452 1 0 Nov18 ? 00:00:02 ora_mman_stone oracle 2454 1 0 Nov18 ? 00:00:09 ora_dbw0_stone oracle 2456 1 0 Nov18 ? 00:00:10 ora_lgwr_stone oracle 2458 1 0 Nov18 ? 00:00:23 ora_ckpt_stone oracle 2460 1 0 Nov18 ? 00:00:07 ora_smon_stone oracle 2462 1 0 Nov18 ? 00:00:00 ora_reco_stone oracle 2464 1 0 Nov18 ? 00:00:18 ora_mmon_stone oracle 2466 1 0 Nov18 ? 00:00:31 ora_mmnl_stone oracle 2468 1 0 Nov18 ? 00:00:01 ora_d000_stone oracle 2470 1 0 Nov18 ? 00:00:00 ora_s000_stone oracle 2478 1 0 Nov18 ? 00:00:01 ora_arc0_stone oracle 2480 1 0 Nov18 ? 00:00:01 ora_arc1_stone oracle 2482 1 0 Nov18 ? 00:00:01 ora_arc2_stone oracle 2484 1 0 Nov18 ? 00:00:01 ora_arc3_stone oracle 2487 1 0 Nov18 ? 00:00:00 ora_qmnc_stone oracle 2491 1 0 Nov18 ? 00:00:01 ora_q001_stone oracle 2509 1 0 Nov18 ? 00:00:13 ora_cjq0_stone oracle 2757 1 0 Nov18 ? 00:00:02 ora_smco_stone oracle 9575 1 0 08:31 ? 00:00:00 ora_q002_stone oracle 12657 1 0 15:00 ? 00:00:00 ora_w001_stone 例子：通过v$bgprocess视图来查看Oracle有哪些后台以及描述 SQL> select name,description from v$bgprocess; NAME DESCRIPTION ----- ---------------------------------------------------------------- PMON process cleanup VKTM Virtual Keeper of TiMe process 我们看到Oracle在非RAC和RAC环境下的后台进程有所不同。
在非RAC环境下，后台进程分为必要和可选两类，此处先看必要的几个进程，RAC的相关进程后面在ASM章节再讲，可选的进程用到的时候再讲。 （1）DBWn(Database Writer)数据库写进程
将数据库缓冲区缓存中修改的块（Dirty）写入数据文件中。参数DB_WEITER_PROCESSES定义DBWn进程的数量。大多数情况下一个数据库写进程（DBW0）就足够了，但是如果你的数据库数据量改动频繁和大量，可以增加额外的数据库写进程（DBW0-DBW9，DBWa-DBWz，最多36个，不要超过CPU的数量）以提高性能，但对于单CPU系统来说，只能有一个数据库写进程。 例子：查看当前系统DBWn的数量以及最大的数量 SQL> show parameter db_writer_processes NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ db_writer_processes integer 1 SQL> select pname from v$process where pname like '%DBW%'; PNAME ----- DBW0 [oracle@oracletest ~]$ ps -ef | grep dbw | grep -v grep oracle 2454 1 0 Nov19 ? 00:00:13 ora_dbw0_stone 最大数量 SQL> select count(*) from v$bgprocess where name like '%DBW%'; COUNT(*) ---------- 36 触发DBWn写数据库缓冲区缓存中的脏块到磁盘的条件有： - 当服务器进程在扫描了一定数量的数据库缓冲区缓存还找不到可用的干净块来写入，则通知DBWn将脏块写入到磁盘
- DBWn定期的写buffer，来推进检查点(实例恢复必须开始的redo thread position）
在许多情况下，DBWn写的数据分散在整个磁盘（scattered write）。因此，DBWn写往往比LGWR的顺序写慢。DBWn执行多块写时可能提高效率，多块写入的数目与操作系统有关。 （2）LGWR（Log Writer）日志写进程 将重做日志缓冲区的数据顺序写入（sequential write）到磁盘的联机重做日志文件。一个实例只有一个LGWR进程 例子：查看当前系统的LGWR SQL> select pname from v$process where pname='LGWR'; PNAME ----- LGWR [oracle@oracletest ~]$ ps -ef | grep lgwr | grep -v grep oracle 2456 1 0 Nov20 ? 00:00:19 ora_lgwr_stone 触发LGWR条件有： - 用户提交事务
- 发生联机重做日志文件切换
- 每隔3秒
- 重做日志缓冲区1/3满或者新产生大于1MB的数据
- DBWR 触发LGWR写入
在DBWn将数据库缓冲区缓存中的脏块写入到磁盘的数据文件之前，这些脏块对应的重做记录必须先写入到磁盘的联机重做日志文件，如果DBWn发现对应的重做记录还没有写入到磁盘的联机重做日志文件，则通知LGWR进行写入，等待写入完成后，DBWn再进行写入。 当用户执行COMMIT语句，事务被分配一个SCN（system change number），LGWR立即将提交记录、提交SCN以及事务的重做条目一起写入到磁盘，而对应修改的数据库缓冲区缓存中的脏块则会延迟到更有效率的时候写入到磁盘，这就是所谓的快速提交机制，也就是说只要将事务的相应重做信息通过LGWR写入到了磁盘，即使该事务修改后的数据还没有写入到磁盘，Oracle数据库就认为已经事务已经完成。 在某些情况下，即使用户没有执行COMMIT语句，LGWR也会将事务的重做信息写入到磁盘，但是只有后面用户执行了COMMIT语句，写入到磁盘的重做信息才会永久有效。 （3）CKPT（Checkpoint）检查点进程 在数据库系统中，写联机重做日志文件和写数据文件是数据库中IO消耗最大的两种操作，在这两种操作中写数据文件属于分散写，写联机重做日志文件是顺序写，因此为了保证数据库的性能，通常数据库都是在提交（commit）完成之前要先保证重做日志都被写入到联机重做日志文件中，而脏数据块保存在数据库缓冲区缓存（buffer cache）中再不定期的分批写入到数据文件中。也就是说日志写入和提交操作是同步的，而数据写入和提交操作是不同步的。这样就存在一个问题，当一个数据库崩溃的时候并不能保证数据库缓冲区缓存里面的脏数据全部写入到数据文件中，这样在实例启动的时候就要使用日志文件进行恢复操作，将数据库恢复到崩溃之前的状态，保证数据的一致性。检查点是这个过程中的重要机制，通过它来确定，恢复时哪些日志应该被扫描并应用于恢复。 例子：查看当前系统的CKPT SQL> select pname from v$process where pname='CKPT'; PNAME ----- CKPT [oracle@oracletest ~]$ ps -ef | grep ckpt | grep -v grep oracle 2503 1 0 Nov29 ? 00:00:22 ora_ckpt_stone 检查点进程将检查点信息（包括检查点位置、SCN、开始恢复的联机重做日志位置等）写入控制文件和数据文件头部并通知DBWn将脏块写入到磁盘。
Checkpoint主要2个作用： - 保证数据库的一致性，这是指通知DBWn将脏块写入到磁盘，保证内存和磁盘上的数据是一样的
- 缩短实例恢复的时间，实例恢复要把实例异常关闭前没有写入到硬盘的脏数据通过日志进行恢复。如果脏块过多，实例恢复的时间也会很长，检查点的发生可以减少脏块的数量，从而提高实例恢复的时间
Oracle数据库有以下几种检查点： - Thread checkpoint（线程检查点），数据库将被某个特定的重做线程所修改的所有缓冲区写入磁盘。数据库中所有实例的线程检查点的集合即为数据库检查点。线程检查点在下列情况下发生：
o 一致的数据库关闭
o ALTER SYSTEM CHECKPOINT 语句
o 联机重做日志切换
o ALTER DATABASE BEGIN BACKUP 语句
- Tablespace and data file checkpoints（表空间和数据文件检查点），表空间检查点是一组数据文件检查点，每个数据文件检查点对表空间中的某个数据文件做检查点操作。这些检查点发生在很多情况下，包括将一个表空间设为只读、将表空间脱机、收缩数据文件、或执行ALTER TABLESPACE BEGIN BACKUP等。
- Incremental checkpoints（增量检查点），增量检查点是一种线程检查点，部分原因是为了避免在联机重做日志切换时写入大量的块。DBWn至少每隔三秒会进行检查以确定是否有工作要做。当 DBWn 将脏缓冲区写入磁盘时, 它会向前推进检查点位置，导致CKPT将检查点位置写入控制文件，而不是数据文件头。
- 其他类型的检查点包括实例和介质恢复检查点，和删除或截断模式对象时的检查点。
前面LGWR和CKPT都提到了SCN（system change number），那么SCN到底是什么呢，SCN用以标识数据库在某个确切时刻提交的版本。在事务提交时，它被赋予一个唯一的标识事务的SCN。SCN同时被作为Oracle数据库的内部时钟机制，可被看做逻辑时钟，每个数据库都有一个全局的SCN生成器。作为数据库内部的逻辑时钟，数据库事务依SCN而排序，Oracle也依据SCN来实现一致性读（Read Consistency）等重要数据库功能。SCN在数据库中是唯一的，并随时间而增加，但是可能并不连贯。除非重建数据库，SCN的值永远不会被重置为0。系统当前SCN并不是在任何的数据库操作时都会改变，SCN通常在事务提交或回滚时改变。在控制文件、数据文件头、数据库、日志文件头、日志文件change vector中都有SCN，但其作用各不相同。 CKPT一定是是在checkpoint发生的时候将数据库当前的SCN更新入数据库文件头和控制文件当中，同时DBWn进程将buffer cache中的脏数据块写到数据文件当中(这个脏数据也一定是当前online redo log保护的那一部分)。同时CKPT进程还会在控制文件当中记录(redo block address)RBA，这个地址用来标志恢复的时候需要从日志中的那个位置开始。 ORACLE中除了有SCN，还有Checkpoint_Change#，那这两者的关系是什么呢，其实Checkpoint_Change#是来源于SCN，SCN是时刻在变化的，Checkpoint_Change#是在数据发生了检查点的时候才改变的，它的值来源于SCN。因为SCN时刻在变化，无法捕获到Checkpoint_Change#等于SCN的时刻。 例子：查看系统当前的SCN SQL> select dbms_flashback.get_system_change_number() SCN from dual; SCN ---------- 2681573 在Oracle数据库中和checkpoint相关的SCN总共有4个
1）System checkpoint SCN (存在于控制文件)
在系统执行checkpoint后，Oracle会更新当前控制文件中的System checkpoint SCN。我们可以通过select checkpoint_change# from v$database来查看。 例子：查看当前的System checkpoint SCN SQL> select checkpoint_change# from v$database; CHECKPOINT_CHANGE# ------------------ 2678314 2）Datafile checkpoint SCN (存在于控制文件)
由于控制文件中记录了Oracle中各个数据库文件的位置和信息，其中当然也包括了Datafile checkpoint SCN，因此在执行checkpoint的时候，Oracle还会去更新控制文件中所记录的各个数据文件的datafile checkpoint SCN。我们可以通过select checkpoint_change# from v$datafile来查看。 例子：查看当前各个数据文件的Datafile checkpoint SCN SQL> select name,checkpoint_change# from v$datafile; NAME CHECKPOINT_CHANGE# -------------------------------------------------------------------------------- ------------------ /u01/app/oracle/oradata/STONE/datafile/o1_mf_system_c06xczt5_.dbf 2678314 /u01/app/oracle/oradata/STONE/datafile/o1_mf_sysaux_c06xczw8_.dbf 2678314 /u01/app/oracle/oradata/STONE/datafile/o1_mf_undotbs1_c06xczwc_.dbf 2678314 /u01/app/oracle/oradata/STONE/datafile/o1_mf_users_c06xczx2_.dbf 2678314 /u01/app/oracle/oradata/STONE/datafile/o1_mf_example_c06xj0bk_.dbf 2678314 3）Start SCN (存在于各个数据文件头)
在执行checkpoint时，Oracle会更新存放在各个实际的数据文件头的Start SCN（注意绝对不会是控制文件中的），这个SCN存在的目的是用于检查数据库启动过程中是否需要做media recovery(介质恢复)我们可以通过select checkpoint_change# from v$datafile_header来查看 例子：查看当前各个数据文件的Start SCN SQL> select name,checkpoint_change# from v$datafile_header; NAME CHECKPOINT_CHANGE# -------------------------------------------------------------------------------- ------------------ /u01/app/oracle/oradata/STONE/datafile/o1_mf_system_c06xczt5_.dbf 2678314 /u01/app/oracle/oradata/STONE/datafile/o1_mf_sysaux_c06xczw8_.dbf 2678314 /u01/app/oracle/oradata/STONE/datafile/o1_mf_undotbs1_c06xczwc_.dbf 2678314 /u01/app/oracle/oradata/STONE/datafile/o1_mf_users_c06xczx2_.dbf 2678314 /u01/app/oracle/oradata/STONE/datafile/o1_mf_example_c06xj0bk_.dbf 2678314 4）End SCN(存在于控制文件)
End SCN也是记录在控制文件当中，每一个所记录的数据文件头都有一个对应的End SCN,这个End SCN一定是存在于控制文件当中。这个SCN存在的绝对意义主要是用来去验证数据库启动过程中是否需要做instance recovery。我们可以通过select name,last_change# from v$datafile来查看。那么在数据库正常运行的情况下，对于read/write的online 数据文件这个SCN号为#FFFFFF(NULL)。 例子：查看当前各个数据文件的End SCN SQL> select name,last_change# from v$datafile; NAME LAST_CHANGE# -------------------------------------------------------------------------------- ------------ /u01/app/oracle/oradata/STONE/datafile/o1_mf_system_c06xczt5_.dbf /u01/app/oracle/oradata/STONE/datafile/o1_mf_sysaux_c06xczw8_.dbf /u01/app/oracle/oradata/STONE/datafile/o1_mf_undotbs1_c06xczwc_.dbf /u01/app/oracle/oradata/STONE/datafile/o1_mf_users_c06xczx2_.dbf /u01/app/oracle/oradata/STONE/datafile/o1_mf_example_c06xj0bk_.dbf 那么我们来看看不需要做实例恢复和需要做实例恢复的情况。 1）如果系统正常关闭，则system checkpoint scn = datafile checkpoint scn = start scn = stop scn，不需要做实例恢复。 例子：查看系统正常关闭后，mount状态下各个SCN的情况 先创建一个脚本，同时获取上面的四个SCN [oracle@oracletest ~]$ cat getscn.sql select 'System Checkpoint SCN - V$Database:checkpoint_change#' "SCN Location",checkpoint_change# from v$database union select 'Datafile Checkpoint SCN - V$Datafile:checkpoint_change#' "SCN Location",checkpoint_change# from v$datafile union select 'Datafile Start SCN - V$Datafile_header:checkpoint_change#' "SCN Location",checkpoint_change# from v$datafile_header union select 'Datafile Stop SCN - V$Datafile:Last_change#' "SCN Location",last_change# from v$datafile; 然后查看当前各个SCN的值 SQL> @getscn SCN Location CHECKPOINT_CHANGE# --------------------------------------------------------- ------------------ Datafile Checkpoint SCN - V$Datafile:checkpoint_change# 2678314 Datafile Start SCN - V$Datafile_header:checkpoint_change# 2678314 Datafile Stop SCN - V$Datafile:Last_change# System Checkpoint SCN - V$Database:checkpoint_change# 2678314 正常关闭数据库并启动到mount状态 SQL> shutdown immediate Database closed. Database dismounted. ORACLE instance shut down. SQL> startup mount ORACLE instance started. Total System Global Area 835104768 bytes Fixed Size 2257840 bytes Variable Size 549456976 bytes Database Buffers 281018368 bytes Redo Buffers 2371584 bytes Database mounted. SQL> @getscn SCN Location CHECKPOINT_CHANGE# --------------------------------------------------------- ------------------ Datafile Checkpoint SCN - V$Datafile:checkpoint_change# 2683010 Datafile Start SCN - V$Datafile_header:checkpoint_change# 2683010 Datafile Stop SCN - V$Datafile:Last_change# 2683010 System Checkpoint SCN - V$Database:checkpoint_change# 2683010 可以看到这四个SCN相等，不需要进行实例恢复。 2）系统异常关闭，则system checkpoint scn = datafile checkpoint scn = start scn , stop scn is NULL，需要进行实例恢复。 SQL> alter database open; Database altered. SQL> startup mount force ORACLE instance started. Total System Global Area 835104768 bytes Fixed Size 2257840 bytes Variable Size 549456976 bytes Database Buffers 281018368 bytes Redo Buffers 2371584 bytes Database mounted. SQL> @getscn SCN Location CHECKPOINT_CHANGE# --------------------------------------------------------- ------------------ Datafile Checkpoint SCN - V$Datafile:checkpoint_change# 2683013 Datafile Start SCN - V$Datafile_header:checkpoint_change# 2683013 Datafile Stop SCN - V$Datafile:Last_change# System Checkpoint SCN - V$Database:checkpoint_change# 2683013 可以看到stop scn为空，需要进行实例恢复。 在正常open数据库的时候，Oracle会将记录在控制文件中的每一个数据文件头的End SCN都设置为#FFFFFF(NULL)，那么如果数据库进行了正常关闭比如(shutdown or shutdown immediate)，这个时候系统会执行一个检查点，这个检查点会将控制文件中记录的各个数据文件头的End SCN更新为当前online数据文件的各个数据文件头的Start SCN，也就是End SCN=Start SCN，如果再次启动数据库的时候发现二者相等，则直接打开数据库，并再次将End SCN设置为#FFFFFF(NULL)，那么如果数据库是异常关闭，那么checkpoint就不会执行，因此再次打开数据库的时候End SCN<>Start SCN，这个时候就需要做实例恢复。 而在数据库的启动过程中，当System Checkpoint SCN=Datafile Checkpoint SCN=Start SCN的时候，Oracle数据库是可以正常启动的，而不需要做任何的media recovery。而如果三者当中有一个不同的话，则需要做media recovery。 （4）SMON（System Monitor）系统监控进程 一个实例只有一个系统监控进程，作用： - 在实例启动时负责对数据库进行恢复。如果是非正常关闭数据库，则当下次启动例程时，SMON进程会自动读重做日志文件，对数据库进行恢复，即执行将已提交的事务写入数据文件中、回退未提交的事务等操作
- 清除已经分配但不再使用的表空间中的临时段。(如果表空间中有大量的盘区，则清除就会花费大量时间，就会影响数据库启动时的性能)
- 合并基于数据字典管理的各个表空间中位置相邻的空闲盘区，使之更容易分配
例子：查看当前系统的SMON SQL> select pname from v$process where pname='SMON'; PNAME ----- SMON [oracle@oracletest ~]$ ps -ef | grep smon | grep -v grep oracle 2505 1 0 Nov29 ? 00:00:04 ora_smon_stone SMON定期检查系统是否需要它，其他的进程如果在需要的时候也会调用它。
实例恢复的目的 实例恢复可确保数据库在一个实例失败后仍能回到一个一致的状态。由于Oracle 数据库对数据文件更改的管理方式会导致数据库的文件可以处于不一致的状态。 重做线程是对实例生成的所有更改的记录。单实例数据库拥有一个重做线程，而一个 Oracle RAC 数据库拥有多个重做线程（每个数据库实例有一个） 当事务提交时，日志写入进程 (LGWR) 将内存中的重做条目和事务 SCN 同时写入联机重做日志。但是，数据库写入进程 (DBWn) 只在它认为最有效率的时候将已修改的数据块写入数据文件。由于这个原因，未提交的更改可能会暂时存在于数据文件中，而已提交的更改也可能还不在数据文件中。 如果某个打开的数据库的实例失败，或者由于 SHUTDOWN ABORT 语句或异常终止，则可能会导致下列情况： - 由某事务已提交的数据块更新还未写入数据文件，而仅写入了联机重做日志中。这些更改必须重新应用到数据库
- 数据文件包含实例失败时尚未提交的更改。这些更改必须回滚，以确保事务一致性
实例恢复只使用联机重做日志文件和当前在线的数据文件，以同步数据文件，并确保它们一致。 Oracle 数据库何时执行实例恢复 是否需要实例恢复取决于重做线程的状态。在数据库实例被打开为读/写模式时，重做线程在控制文件中被标记为打开，而当实例被一致关闭时，重做线程被标记为关闭。如果重做线程在控制文件中被标记为打开，但没有活动的实例持有对应于这些线程的线程队列，则数据库将需要实例恢复。 Oracle 数据库在以下情况下自动执行实例恢复： - 单实例数据库或 Oracle RAC 数据库的所有实例失败后第一次打开数据库。这种形式的实例恢复也称为崩溃恢复。Oracle 数据库一起恢复所有已终止实例的联机重做线程。
- 只是 Oracle RAC 数据库中的某些、但不是所有实例失败。实例恢复将由配置中的某个存活实例自动进行。
SMON 后台进程自动执行实例恢复并应用联机重做记录。而不需要任何用户干预。 实例恢复检查点的重要性 实例恢复使用检查点来确定必须将哪些更改应用到数据文件。检查点位置始终保证所有比其 SCN 低的检查点所对应的已提交更改都已保存到数据文件。 联机重做日志中的重做线程如下图：
实例恢复期间，数据库必须应用检查点位置和重做线程结尾之间发生的更改。如图 13-5 所示， 某些更改可能已经写入数据文件。但是，只有其 SCN低于检查点位置的更改，才保证已被写到了磁盘上。 实例恢复阶段 实例恢复的第一阶段称为缓存恢复或前滚，这涉及将联机重做日志中记录的所有更改重新应用到数据文件。因为回滚数据记录在联机重做日志中，前滚也会重新生成相应的撤消段。 前滚会遍历各个必要的联机重做日志，以将数据库推进到一个更前的一致时间点。前滚之后，数据块包含记录在联机重做日志文件中的所有已提交更改。这些文件可能还包含未提交的更改，要么是在实例失败前保存到数据文件中的，或者是在缓存恢复过程中引入的。 前滚之后，任何未提交的更改必须被撤消。Oracle 数据库使用检查点位置，保证每个低于其 SCN 的已提交更改都已保存到磁盘。Oracle 数据库应用撤消块，以回滚数据块中在实例失败前写入的或缓存恢复过程中引入的未提交更改。这一阶段称为回滚或事务恢复。 前滚和回滚如下图：
Oracle 数据库可以根据需要同时回滚多个事务。实例失败时的所有活动事务被标记为终止。新事务可以自己回滚个别块以获取所需的数据，而不必等待 SMON 进程来回滚这些已终止的事务。 ( “前滚和回滚”是Oracle数据库实例发生意外崩溃，重新启动的时候，由SMON进行的自动恢复过程。下面通过模拟实例和讲解介绍这个过程。 失败前场景说明 日志中记录过程如下： 1、事务A进行之后，结束commit。之后系统进行了一次checkpoint A； 2、Checkpoint之后，进行事务B，结束commit； 3、进行事务C，C事务量较大，其中进行了一定量的Redo Log文件写入。之后系统断电； 1、系统启动过程，进入实例恢复阶段 当实例意外中断的时候，各类型文件，包括控制文件、数据文件和日志文件上，会存在不一致的问题。这种不一致主要体现在SCN值的差异上。 实例在启动的时候，经过三阶段（nomount、mount和open）。在open之前，会进行这种不一致现象的检查，如果出现不一致，要启动SMON进程的恢复流程。 SMON是Oracle实例的一个后台进程，主要负责进行系统监控恢复。进行恢复的依据主要是Redo Log记录。 2、前滚进程 SMON首先找到最后SCN记录的Redo Log File。寻找最后一个打入的Checkpoint。 顺序找到CheckPoint A之后，表示A之前的所有事务都是完全写入到数据文件中，不存在不一致性问题。恢复过程从Checkpoint A开始，Oracle开始依据重做日志Redo Log的系列条目，进行推进。 首先遇到了事务B信息，由于事务B已经commit，所以事务B所有相关的Redo Log条目已经全都写入到Redo Log File中。所以，按照日志继续条目推进，完全可以重演replay，并且应用apply事务B的全部过程。 这样，事务B全部实现，最终将通过DBWn完全写入到数据文件中。所以，实例失败之前提交commit的事务B，完全恢复。 进入事务C的范畴，由于一部分事务C的Redo Log条目已经进入Redo Log File中，所以在进行前滚的时候，一定会replay到这部分的内容。不过，这部分内容中不可能出现commit的标记。所以，前滚的结果一定是遇到实例突然中断的那个时点。此时replay的结果是，事务C没有提交。这样结束了前滚过程，进入回滚阶段。 3、回滚过程 对事务C，要进行回滚过程，释放所有相关资源。从Undo空间中寻找到旧版本SCN的数据块信息，来进行SGA中Buffer Cache数据块恢复。 ) ( Crash Recovery 过程 当数据库突然崩溃，而还没有来得及将buffer cache里的脏数据块刷新到数据文件里，同时在实例崩溃时正在运行着的事务被突然中断，则事务为中间状态，也就是既没有提交也没有回滚。这时数据文件里的内容不能体现实例崩溃时的状态。这样关闭的数据库是不一致的。 下次启动实例时，Oracle会由SMON进程自动进行实例恢复。实例启动时，SMON进程会去检查控制文件中所记录的、每个在线的、可读写的数据文件的END SCN号。 数据库正常运行过程中，该END SCN号始终为NULL，而当数据库正常关闭时，会进行完全检查点，并将检查点SCN号更新该字段。 而崩溃时，Oracle还来不及更新该字段，则该字段仍然为NULL。当SMON进程发现该字段为空时，就知道实例在上次没有正常关闭，于是由SMON进程就开始进行实例恢复了。 1.2.1 前滚 SMON进程进行实例恢复时，会从控制文件中获得检查点位置。于是，SMON进程到联机日志文件中，找到该检查点位置，然后从该检查点位置开始往下，应用所有的重做条目，从而在buffer cache里又恢复了实例崩溃那个时间点的状态。这个过程叫做前滚，前滚完毕以后，buffer cache里既有崩溃时已经提交还没有写入数据文件的脏数据块，也还有事务被突然终止，而导致的既没有提交又没有回滚的事务所弄脏的数据块。 1.2.2 回滚 前滚一旦完毕，SMON进程立即打开数据库。但是，这时的数据库中还含有那些中间状态的、既没有提交又没有回滚的脏块，这种脏块是不能存在于数据库中的，因为它们并没有被提交，必须被回滚。打开数据库以后，SMON进程会在后台进行回滚。 有时，数据库打开以后，SMON进程还没来得及回滚这些中间状态的数据块时，就有用户进程发出读取这些数据块的请求。这时，服务器进程在将这些块返回给用户之前，由服务器进程负责进行回滚，回滚完毕后，将数据块的内容返回给用户。 总之，Crash Recovery时，数据库打开会占用比正常关闭更长的时间。 1.2.3 必须先前滚，在回滚 回滚段实际上也是以回滚表空间的形式存在的，既然是表空间，那么肯定就有对应的数据文件，同时在buffer cache 中就会存在映像块，这一点和其他表空间的数据文件相同。 当发生DML操作时，既要生成REDO（针对DML操作本身的REDO Entry）也要生成UNDO（用于回滚该DML操作，记录在UNDO表空间中），但是既然UNDO信息也是使用回滚表空间来存放的，那么该DML操作对应的UNDO信息（在BUFFER CACHE生成对应中的UNDO BLOCK）就会首先生成其对应的REDO信息（UNDO BLOCK's REDO Entry）并写入Log Buffer中。 这样做的原因是因为Buffer Cache中的有关UNDO表空间的块也可能因为数据库故障而丢失，为了保障在下一次启动时能够顺利进行回滚，首先就必须使用REDO日志来恢复UNDO段（实际上是先恢复Buffer Cache中的脏数据块，然后由Checkpoint写入UNDO段中），在数据库OPEN以后再使用UNDO信息来进行回滚，达到一致性的目的。 生成完UNDO BLOCK's REDO Entry后才轮到该DML语句对应的REDO Entry，最后再修改Buffer Cache中的Block，该Block同时变为脏数据块。 实际上，简单点说REDO的作用就是记录所有的数据库更改，包括UNDO表空间在内。 ) （5）PMON（Process Monitor）进程监控进程 作用： - 在用户进程失败的时候执行进程恢复，并负责清除数据库缓冲区缓存，释放进程使用的资源。比如说重置当前活动的事务表，释放不需要的locks，清理进程id（隐式回滚）。
- 周期性的检查调度器或者服务器进程，并在中断运行后进行重启（故意中断的除外）。
- 监控超时的空闲会话。
- 动态注册数据库服务到监听。当一个实例开启，PMON会查看listener是否正在运行。如果listener正在运行，那么PMON会传递相关的参数，如果没有运行那么PMON定期的尝试连接。
例子：查看当前系统的PMON SQL> select pname from v$process where pname='PMON'; PNAME ----- PMON [oracle@oracletest ~]$ ps -ef | grep pmon | grep -v grep oracle 2480 1 0 Nov29 ? 00:00:10 ora_pmon_stone PMON定期检查系统是否需要它，其他的进程如果在需要的时候也会调用它。
（6）RECO（Recover Process）恢复进程 在分布式数据库中，RECO进程自动解决分布式事务发生错误的情况。一个节点上的RECO进程自动连接到没有被正确处理事务相关的数据库上面。当RECO建立了数据库之间的连接，它会自动的解决没有办法处理的事务，删除与该事务相关的行（清理事务表）。 例子：查看当前系统的PMON SQL> select pname from v$process where pname='RECO'; PNAME ----- RECO [oracle@oracletest ~]$ ps -ef | grep reco | grep -v grep oracle 2507 1 0 Nov29 ? 00:00:01 ora_reco_stone
（7）ARCn（Archiver Process）归档进程 作用： - 在重做日志切换后拷贝重做日志文件到存储上面
- 收集事务的重做数据并传输到备库
归档进程只有数据库在归档模式并且自动归档开启的时候存在（从Oracle10g开始，log_archive_start参数已经被废弃，只要启动数据库的归档模式，Oracle就会启用自动归档）。系统默认有4个归档进程。可以有多个归档目的地，建议至少为每一个归档目的地分配一个归档进程。 例子：查看数据库当前是否是归档模式 SQL> archive log list Database log mode Archive Mode Automatic archival Enabled Archive destination USE_DB_RECOVERY_FILE_DEST Oldest online log sequence 34 Next log sequence to archive 36 Current log sequence 36 例子：查看当前系统的ARCn SQL> select pname from v$process where pname like '%ARC%'; PNAME ----- ARC0 ARC1 ARC2 ARC3 [oracle@oracletest ~]$ ps -ef | grep arc | grep -v grep oracle 2523 1 0 Nov29 ? 00:00:01 ora_arc0_stone oracle 2525 1 0 Nov29 ? 00:00:02 ora_arc1_stone oracle 2527 1 0 Nov29 ? 00:00:01 ora_arc2_stone oracle 2529 1 0 Nov29 ? 00:00:01 ora_arc3_stone
4、数据库进程启动顺序 如果我们安装了GI，那么操作系统一启动，就会去带动我们的GI，这是由于GI安装的时候会去修改操作系统的启动文件/etc/inittab，在这个文件里面增加一个启动GI的入口点/etc/init.d/init.ohasd，所以操作系统在启动的时候，就会运行这个命令/etc/init.d/init.ohasd run >/dev/null 2&1 [root@oracletest1 ~]# cat /etc/init/oracle-ohasd.conf # Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. # # Oracle OHASD startup start on runlevel [35] stop on runlevel [!35] respawn exec /etc/init.d/init.ohasd run >/dev/null 2>&1 5、数据库存储结构 Oracle数据库必须包含以下三种文件： - 控制文件（Control files）：包含数据库的信息以及备份的信息
- 数据文件（Data files）：包含数据字典和用户数据
- 联机重做日志文件（Online redo log files）：包含数据的改变信息，保证不丢失数据
Oracle数据库正常稳定运行建议还包括以下文件： - 参数文件（Parameter files）：包含实例启动时的参数信息
- 密码文件（Password file）：允许用户使用sysdba、sysoper和sysasm角色远程连接到数据库进行管理操作
- 备份文件（Backup files）：用于数据库恢复
- 归档重做日志文件（Archived redo log files）：联机重做日志文件的归档
- 跟踪文件（Trace files）：用于记录服务器进程或者后台进程的错误信息
- 告警文件（Alert log file）：记录数据库运行的信息以及错误
Oracle数据库的逻辑结构和物理结构
逻辑上，一个数据库包含多个表空间，一个表空间包含多个段，一个段包含多个区，一个区包含多个数据块。 - 数据块（data blocks）：逻辑存储结构中最小的逻辑单位，数据库输入输出操作的最小存储单位，由多个操作系统块构成。
- 区（extent）：由一组连续的数据块构成，是存储分配的最小单位，是表中数据增大的基本单位。
- 段（segment）：由数据区构成，是独立的逻辑存储结构。段是为特定的数据对象分配的一系列数据区，占用磁盘空间。不是所有的数据库对象都会分配段，比如视图、触发器、包。4种主要类型的段：
（1）数据段，创建表时自动创建以表名字命名的数据段
（2）索引段，创建索引时自动创建以索引名字命名的索引段
（3）回滚段：存储undo信息
（4）临时段：SQL语句需要临时工作区（比如排序）就会用到临时段
- 表空间（tablespace）：表空间是数据库的最大逻辑划分区域，用来存放表，索引，回滚段等数据对象，任何数据对象在创建时都必须指定存储在某个表空间中。
表空间与数据文件相对应，一个表空间由一个或多个数据文件组成，一个数据文件只属于一个表空间，单个数据文件最大大小为（2^22-1）*DB_BLOCK_SIZE。如果是大文件表空间，则只有一个数据文件，最大可以到（2^32-1）*32K=128T。 例子：查看当前数据库的控制文件 SQL> select * from v$controlfile; STATUS NAME IS_ BLOCK_SIZE FILE_SIZE_BLKS ------- -------------------------------------------------------------------------------- --- ---------- -------------- /u01/app/oracle/oradata/STONE/controlfile/o1_mf_c06xh9fs_.ctl NO 16384 596 /u01/app/oracle/fast_recovery_area/STONE/controlfile/o1_mf_c06xh9jx_.ctl YES 16384 596 例子：查看当前数据库的数据文件及表空间 SQL> select file_name,tablespace_name from dba_data_files; FILE_NAME TABLESPACE_NAME -------------------------------------------------------------------------------- ------------------------------ /u01/app/oracle/oradata/STONE/datafile/o1_mf_users_c06xczx2_.dbf USERS /u01/app/oracle/oradata/STONE/datafile/o1_mf_undotbs1_c06xczwc_.dbf UNDOTBS1 /u01/app/oracle/oradata/STONE/datafile/o1_mf_sysaux_c06xczw8_.dbf SYSAUX /u01/app/oracle/oradata/STONE/datafile/o1_mf_system_c06xczt5_.dbf SYSTEM /u01/app/oracle/oradata/STONE/datafile/o1_mf_example_c06xj0bk_.dbf EXAMPLE 例子：查到当前数据库的联机重做日志文件 SQL> select * from v$logfile; GROUP# STATUS TYPE MEMBER IS_ ---------- ------- ------- -------------------------------------------------------------------------------- --- 3 ONLINE /u01/app/oracle/oradata/STONE/onlinelog/o1_mf_3_c06xhj1g_.log NO 3 ONLINE /u01/app/oracle/fast_recovery_area/STONE/onlinelog/o1_mf_3_c06xhj37_.log YES 2 ONLINE /u01/app/oracle/oradata/STONE/onlinelog/o1_mf_2_c06xhdlj_.log NO 2 ONLINE /u01/app/oracle/fast_recovery_area/STONE/onlinelog/o1_mf_2_c06xhdnc_.log YES 1 ONLINE /u01/app/oracle/oradata/STONE/onlinelog/o1_mf_1_c06xh9t5_.log NO 1 ONLINE /u01/app/oracle/fast_recovery_area/STONE/onlinelog/o1_mf_1_c06xh9xt_.log YES 6 rows selected. 例子：查到当前数据库的归档日志文件 SQL> archive log list; Database log mode Archive Mode Automatic archival Enabled Archive destination USE_DB_RECOVERY_FILE_DEST Oldest online log sequence 47 Next log sequence to archive 49 Current log sequence 49 SQL> show parameter db_recovery_file_dest NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ db_recovery_file_dest string /u01/app/oracle/fast_recovery_ area db_recovery_file_dest_size big integer 4182M SQL> select name,sequence#,first_change# from v$archived_log; NAME SEQUENCE# FIRST_CHANGE# ------------------------------------------------------------------------------------------ ---------- ------------- /u01/app/oracle/fast_recovery_area/STONE/archivelog/2015_09_24/o1_mf_1_5_c06xz88j_.arc 5 987870 /u01/app/oracle/fast_recovery_area/STONE/archivelog/2015_09_24/o1_mf_1_6_c0784v9r_.arc 6 997228 例子：查看当前数据库的参数文件 SQL> !ls /u01/app/oracle/product/11.2.0/dbhome_1/dbs/spfilestone.ora /u01/app/oracle/product/11.2.0/dbhome_1/dbs/spfilestone.ora 例子：查看当前会话的初始化参数 SQL> show parameters; NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ O7_DICTIONARY_ACCESSIBILITY boolean FALSE 例子：查看spfile中的初始化参数 SQL> show spparameters; SID NAME TYPE VALUE -------- ----------------------------- ----------- ---------------------------- * O7_DICTIONARY_ACCESSIBILITY boolean * active_instance_count integer * aq_tm_processes integer * archive_lag_target integer * asm_diskgroups string * asm_diskstring string * asm_power_limit integer * asm_preferred_read_failure_gr string oups * audit_file_dest string /u01/app/oracle/admin/stone/ adump 例子：查看当前数据库的密码文件 SQL> !ls /u01/app/oracle/product/11.2.0/dbhome_1/dbs/orapwstone /u01/app/oracle/product/11.2.0/dbhome_1/dbs/orapwstone 例子：使用V$PWFILE_USERS这个视图可以查看用户是否被授予了SYSDBA,，SYSOPER，SYSASM系统权限 SQL> select * from V$PWFILE_USERS; USERNAME SYSDB SYSOP SYSAS ------------------------------ ----- ----- ----- SYS TRUE TRUE FALSE SQL> grant sysdba to hr; Grant succeeded. SQL> select * from V$PWFILE_USERS; USERNAME SYSDB SYSOP SYSAS ------------------------------ ----- ----- ----- SYS TRUE TRUE FALSE HR TRUE FALSE FALSE SQL> revoke sysdba from hr; Revoke succeeded. SQL> select * from V$PWFILE_USERS; USERNAME SYSDB SYSOP SYSAS ------------------------------ ----- ----- ----- SYS TRUE TRUE FALSE 例子：查看当前数据库的跟踪文件以及告警文件 11g之前是由参数background_dump_dest指定位置，11g使用ADR后，在ADR对应目录下。 SQL> show parameter background_dump_dest NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ background_dump_dest string /u01/app/oracle/diag/rdbms/sto ne/stone/trace SQL> select * from v$diag_info; INST_ID NAME VALUE ---------- ------------------------------ -------------------------------------------------------------------------------- 1 Diag Enabled TRUE 1 ADR Base /u01/app/oracle 1 ADR Home /u01/app/oracle/diag/rdbms/stone/stone 1 Diag Trace /u01/app/oracle/diag/rdbms/stone/stone/trace 1 Diag Alert /u01/app/oracle/diag/rdbms/stone/stone/alert 1 Diag Incident /u01/app/oracle/diag/rdbms/stone/stone/incident 1 Diag Cdump /u01/app/oracle/diag/rdbms/stone/stone/cdump 1 Health Monitor /u01/app/oracle/diag/rdbms/stone/stone/hm 1 Default Trace File /u01/app/oracle/diag/rdbms/stone/stone/trace/stone_ora_678.trc 1 Active Problem Count 0 1 Active Incident Count 0 11 rows selected. 例子：查看当前数据库USER表空间DEPT的表段的段信息 SQL> select owner,segment_name,segment_type,tablespace_name,bytes,blocks from dba_segments where tablespace_name='USERS' and segment_name='DEPT'; OWNER SEGMENT_NAME SEGMENT_TYPE TABLESPACE_NAME BYTES BLOCKS ------------------------------ ------------------------------ ------------------ ------------------------------ ---------- ---------- SCOTT DEPT TABLE USERS 65536 8 HR DEPT TABLE USERS 65536 8 例子：查看当前数据库USER表空间DEPT的表段的区信息 SQL> select segment_name,extent_id,block_id,blocks from dba_extents where segment_name='DEPT'; SEGMENT_NAME EXTENT_ID BLOCK_ID BLOCKS ------------------------------ ---------- ---------- ---------- DEPT 0 94960 8 DEPT 0 128 8 DEPT 0 688 8 例子：查看块大小 SQL> show parameter db_block_size NAME TYPE VALUE ------------------------------------ ----------- ------------------------------ db_block_size integer 8192 SYSTEM和SYSAUX表空间 SYSTEM和SYSAUX表空间是数据库创建的时候自动创建的表空间，数据库运行的时候都必须online，Oracle建议不要在这2个表空间存放业务数据。 - SYSTEM表空间是最重要的表空间，包含数据字典等核心功能
- SYSAUX表空间包含数据库的一些额外组件信息，例如EM知识库信息
自动存储管理ASM ASM主要用于Oracle RAC环境的并发访问，是一个集群文件系统，主要用于存放Oracle数据库的文件，包含数据文件，控制文件，联机日志文件，备份，归档等，不能存放操作系统的文件，比如数据库安装文件，如果要放的话，就需要在ASM上面创建一个ACFS文件系统。我们一般主要使用ASM的磁盘组，类似RAID，做了条带化和镜像。
ASM存储组件 ASM磁盘可以是物理磁盘或者分区、存储的LUN、LV或者网络文件，多个ASM磁盘构成ASM磁盘组，每个ASM磁盘划分成多个分配单元（AU），分配单元是ASM最小的连续分配磁盘空间，可以设置分配单元为1、2、4、8、16、32或者64M，一个或者多个分配单元构成ASM区（extent），一个或者多个区构成ASM文件。ASM文件只能在一个磁盘组中。
6、数据库的交互 描述一下用户和服务器进程在不同的机器上面，通过网络与数据库进行交互的最基本的过程。 （1）数据库实例启动 （2）用户发起一个用户进程 （3）服务器上的监听检测到连接请求，创建一个服务器进程 （4）用户发起DML语句 （5）服务器进程收到DML语句，检查共享池中是否有同样的SQL语句的共享SQL区，如果有，服务器进程确认用户的访问权限并使用共享SQL区去处理这个语句，如果没有，分配新的共享SQL区去解析和处理语句。 （6）服务器进程从数据文件或者数据库缓冲区缓存获取必要的数据 （7）服务器进程在SGA中修改数据。事务提交后，LGWR将修改动作写入联机重做日志文件，DBWn在合适的时候将修改的块更新的磁盘上 （8）如果事务成功，服务器进程通过网络给应用发送消息，如果失败，将会返回错误
7、相关习题 （1）Identify the memory component from which memory may be allocated for:
Session memory for the shared serverBuffers for I/O slavesOracle Database Recovery Manager (RMAN) backup and restore operations.
A. Large Pool
B. Redo Log Buffer
C. Database Buffer Cache
D. Program Global Area (PGA) 答案：A （2）Which two statements are true about Shared SQL Area and Private SQL Area? (Choose two.)
A. Shared SQL Area will be allocated in the shared pool
B. Shared SQL Area will be allocated when a session starts
C. Shared SQL Area will be allocated in the large pool always
D. The whole of Private SQL Area will be allocated in the Program Global Area (PGA) always
E. Shared SQL Area and Private SQL Area will be allocated in the PGA or large pool
F. The number of Private SQL Area allocations is dependent on the OPEN_CURSORS parameter 答案：AF （3）Which three statements are correct about temporary tables? (Choose three.)
A. Indexes and views can be created on temporary tables
B. Both the data and structure of temporary tables can be exported
C. Temporary tables are always created in a user's temporary tablespace
D. The data inserted into a temporary table in a session is available to other sessions
E. Data Manipulation Language (DML) locks are never acquired on the data of temporary tables 答案：ACE （4）Which two statements correctly describe the relation between a data file and the logical database structures? (Choose two)
A. An extent cannot spread across data files.
B. A segment cannot spread across data files.
C. A data file can belong to only one tablespace.
D. A data file can have only one segment created in it.
E. A data block can spread across multiple data files as it can consist of multiple operating system (OS) blocks. 答案：AC （5）Which two statements are true regarding a tablespace? (Choose two.)
A. It can span multiple databases
B. It can consist of multiple data files
C. It can contain blocks of different files
D. It can contains segments of different sizes
E. It can contains a part of nonpartitioned segment 答案：BD （6）You execute this command to drop the ITEM table, which has the primary key referred in the ORDERS table:
SQL> DROP TABLE scott.item CASCADE CONSTRAINTS PURGE;
Which two statements are true about the effect of the command? (Choose two.)
A. No flashback is possible to bring back the ITEM table.
B. The ORDERS table is dropped along with the ITEM table.
C. The dependent referential integrity constraints in the ORDERS table are disabled.
D. The dependent referential integrity constraints in the ORDERS table are removed.
E. The table definition of the ITEM table and associated indexes are placed in the recycle bin. 答案：AD （7）You executed this command to create a temporary table:
SQL> CREATE GLOBAL TEMPORARY TABLE report_work_area (
Startdate DATE,
enddate DATE,
class CHAR(20)
) ON COMMIT PRESERVE ROWS;
Which statement is true about the rows inserted into the REPORT_WORK_AREA table during a transaction?
A. The rows stay in the table only until session termination
B. The rows stay in the table only until the next transaction starts on the table
C. The rows are visible to all current sessions after the transaction in committed
D. The rows stay available for subsequent sessions after the transaction is committed 答案：A （8）You want to access employee details contained in flat files as part of the EMPLOYEE table. You plan to add a new column to the EMPLOYEE table to achieve this.
Which data types would you use for the new column?
A. CLOB
B. BLOB
C. BFILE
D. LONG RAW 答案：C （9）Note the following structures in your database server:
1. Extents
2. OS Blocks
3. Tablespace
4. Segments
5. Oracle Data Block
Which option has the correct arrangement of these structures from the smallest to the largest?
A. 2, 5, 1, 4, 3
B. 1, 2, 3, 4, 5
C. 5, 2, 1, 3, 4
D. 2, 1, 5, 4, 3 答案：A （10）See the Exhibit:
Identify the component marked with a question mark:
A. Checkpoint (CKPT)
B. Process Monitor (PMON)
C. Archiver Processes (ARcn)
D. Recoverer Process (RECO)
E. Memory Manager Process (MMAN) 答案：A （11）Why does performance degrade when many UPDATE, INSERT or DELETE statements are issued on a table that has an associated bitmap index?
A. The DML operations re-create the bitmap index blocks
B. The bitmap index is rebuilt automatically after a DML operation
C. The smallest amount of a bitmap that can be locked is a bitmap segment
D. Additional time is taken to remove NULL values from the bitmap index after a DML operation 答案：C （12）Which is the correct description of a pinned buffer in the database buffer cache?
A. The buffer is currently being accessed
B. The buffer is empty and has not been used
C. The contents of the buffer have changed and must be flushed to the disk by the DBWn process
D. The buffer is a candidate for immediate aging out and its contents are synchronized with the block contents on the disk 答案：A （13）View the Exhibit to examine the output produced by the following query at three different times since the database instance started and has experienced workloads of different capacities: SQL> SELECT substr(component, 0, 10) COMP, current_size CS, user_specified_size US
FROM v$memory_dynamic_components
WHERE current_size!=0;
What do you infer from this?
此主题相关图片如下：
A. The database instance is running with manual PGA management.
B. The database instance is running with manual shared memory management.
C. The database instance has the MEMORY_TARGET value set to a nonzero value. D. All sessions are connected to the database instance in dedicated mode, and no RMAN or parallel query operations have been performed. 答案：C （14）Your database instance is started using the server parameter file (SPFILE). You executed a command to change the value of the LOG_BUFFER initialization parameter: ALTER SYSTEM SET LOG_BUFFER=32M SCOPE=BOTH; What would be the outcome of this command?
A. The command succeeds only if Automatic Memory Management is not enabled.
B. The command succeeds, but you need to restart the database for changes to take effect.
C. The command returns an error because the size of the redo log buffer cannot be changed dynamically.
D. The parameter value is changed and it comes into effect as soon as space becomes available in the System Global Area (SGA). 答案：C （15）Which two statements about the background process of the database writer are true? (Choose two.)
A. It is possible to have multiple database writers in an Oracle instance.
B. It writes dirty buffers, if any, to data files whenever a checkpoint occurs.
C. It writes dirty buffers, if any, to data files whenever a transaction commits.
D. It writes dirty buffers, if any, to data files before the log writer (LGWR) writes. 答案：AB （16）Which two statements are true regarding a PL/SQL package body? (Choose two.)
A. It cannot be created without a package specification.
B. It cannot invoke subprograms defined in other packages.
C. It can contain only the subprograms defined in the package specification.
D. It can be changed and recompiled without making the package specification invalid. 答案：AD （17）Note the following functionalities of various background processes:
1. Record the checkpoint information in data file headers.
2. Perform recovery at instance startup.
3. Cleanup unused temporary segments.
4. Free the resources used by a user process when it fails.
5. Dynamically register database services with listeners.
6. Monitor sessions for idle session timeout.
Which option has the correct functionalities listed for a background process?
A. Archiver Process (ARCn): 1, 2, 5
B. System Monitor Process (SMON): 1, 4, 5
C. Process Monitor Process (PMON): 4, 5, 6
D. Database Writer Process (DBWn): 1, 3, 4 答案：C （18）Which three statements are correct about temporary tables? (Choose three.)
A. Indexes and views can be created on temporary tables.
B. Both the data and the structure of temporary tables can be exported.
C. Temporary tables are always created in a user's temporary tablespace.
D. The data inserted into a temporary table in a session is available to other sessions.
E. Data manipulation language (DML) locks are never acquired on the data of temporary tables. 答案：ACE （19）Which three statements are true about logical structures of the Oracle database? (Choose three.)
A. Each segment contains one or more extents.
B. Multiple tablespaces can share a single data file.
C. A data block is the smallest unit of input/output (I/O) in data files.
D. It is possible to have tablespaces of different block sizes in a database.
E. Each data block in the database always corresponds to one operating system block. 答案：ACD （20）In a new installation of Oracle Database 11g, you perform these activities:
1. Organize software and data on different subdirectories to avoid poor performance.
2. Use consistent naming conventions for database files.
3. Separate administrative information pertaining to the database in different directories.
Which option corresponds to the type of activities you performed?
A. Oracle Managed Files
B. Oracle Grid Architecture
C. Optimal Flexible Architecture
D. Oracle database architecture
E. Automatic Storage Management 答案：C
| 
|手机版|小黑屋|重庆思庄Oracle、Redhat认证学习论坛
( 渝ICP备12004239号-4 )
发表于 2016-1-6 09:13:48
QQ好友和群
QQ空间
腾讯微博
腾讯朋友
收藏
支持
反对