consistent gets ：Number of times a consistent read was requested for a block。
是oracle在查询开始的时候，所获得的数据必须是在时间点上一致的。假定查询开始的时候所有数据都是已经提交的，查询开始之后，若数据发生了变化，则查询需要去从回滚段中获得变化前的数据，而若数据没有发生变化，则不用去回滚段中读了。不管是否去回滚段中读，在概念上来讲，这种数据获取方式都叫 consistent gets 。 这仅仅表示一种期望，需要获得一致的时间点的数据，为此可能需要去回滚段中获得数据但并不表示一定从回滚段中得到数据。
顺便说一句 the number of blocks visited = consistent gets + db block gets
Some Oracle experts claim that these undocumented underlying mechanism can be revealed and that these consistent gets metrics may tell us about data clustering Mladen Gogala, author of "Easy Oracle PHP" makes these observations about consistent gets:
"The [consistent gets] overhead is the time spent by Oracle to maintain its own structures + the time spent by OS to maintain its own structures. So, what exactly happens during a consistent get in the situation described? As I don't have access to the source code, I cannot tell precisely, with 100% of certainty, but based on my experience, the process goes something like this:
1) Oracle calculates the hash value of the block and searches the SGA hash table for the place where the block is located.
2) Oracle checks the SCN of the block and compares it with the SCN of the current transaction. Here, I'll assume that this check will be OK and that no read consistent version needs to be constructed.
3) If the instance is a part of RAC, check the directory and see whether any other instance has modified the block. It will require communication with the GES process using the IPC primitives (MSG system calls). MSG system calls are frequently implemented using device driver which brings us to the OS overhead (context switch, scheduling)
4) If everything is OK, the block is paged in the address space of the requesting process. For this step I am not exactly sure when does it happen, but it has to happen at some point. Logically, it would look as the last step, but my logic may be flawed. Here, of course, I assume a soft fault. Hard fault would mean that a part of SGA was swapped out.
All of this is an overhead of a consistent get and it is the simplest case. How much is it in terms of microseconds, depends on many factors, but the overhead exists and is strictly larger then zero. If your SQL does a gazillion of consistent gets, it will waste significant CPU power and time to perform that."
注意最后一段这句：How much is it in terms of microseconds, depends on many factors,