blocks|key|2877133|text|在具有不可重复读取的系统中，事务A的第二个查询的结果将反映事务B中的更新-它将看到新的数量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2877134|在允许幻象读取的系统中，如果事务B插入ID+=+1的新行，则事务A将在执行第二个查询时看到新行；也就是说，幻象读取是不可重复读取的特例。|2877135|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In a system with non-repeatable reads, the result of Transaction A's second query will reflect the update in Transaction B - it will see the new amount.

In a system that allows phantom reads, if Transaction B were to insert a new row with ID = 1, Transaction A will see the new row when the second query is executed; i.e. phantom reads are a special case of non-repeatable read.

blocks|key|226671|text|From+Wikipedia+(它有很好的和详细的例子)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|226672|226673|当在事务过程中检索一行两次，并且行中的值在两次读取之间不同时，就会发生不可重复的读取。|blockquote|226674|226675|226676|和|226677|226678|在事务过程中执行两个相同的查询，并且第二个查询返回的行集合与第一个查询返回的行集合不同时，就会发生幻影读取。|226679|226680|226681|简单的例子：|226682|226683|用户A将同一查询运行两次。在这两者之间，用户B运行一个事务和commits.|unordered-list-item|226684|Non-repeatable读取:用户A查询的A行在第二次time.|226685|Phantom读取时具有不同的值:查询中的所有行在前后具有相同的值，但选择了不同的行(因为B删除或插入了一些行)。示例:如果添加或删除了行，即使没有任何受影响的行本身被更新，select+sum(x)+from+table;也会返回不同的结果。|style|CODE|226686|226687|226688|在上面的例子中，使用哪种隔离级别？|226689|226690|226691|您需要什么隔离级别取决于您的应用程序。“更好的”隔离级别(比如降低的并发性)会带来很高的成本。|226692|在您的示例中，您将不会有一个phantom，因为您只从一行(由主键标识)中进行选择。您可以使用不可重复的读取，因此如果这是一个问题，您可能需要一个隔离级别来防止这种情况。在Oracle中，事务A也可以发出SELECT+FOR+UPDATE，然后事务B在A完成之前不能更改行。|226693|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Isolation_%2528database_systems%2529#Non-repeatable_reads^0|0|E|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|2F|P|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|D|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1P|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1Q|8|@]|9|@]|C|$]]|$1|I|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|1S|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|1T|8|@]|9|@]|C|$]]|$1|M|3|N|5|G|7|1U|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1V|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1W|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1X|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|T|3|U|5|V|7|1Z|8|@]|9|@]|C|$]]|$1|W|3|X|5|V|7|20|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|V|7|21|8|@$A|22|B|23|10|11]]|9|@]|C|$]]|$1|12|3|-4|5|6|7|24|8|@]|9|@]|C|$]]|$1|13|3|-4|5|6|7|25|8|@]|9|@]|C|$]]|$1|14|3|15|5|G|7|26|8|@]|9|@]|C|$]]|$1|16|3|-4|5|6|7|27|8|@]|9|@]|C|$]]|$1|17|3|-4|5|6|7|28|8|@]|9|@]|C|$]]|$1|18|3|19|5|6|7|29|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|6|7|2A|8|@]|9|@]|C|$]]|$1|1C|3|-4|5|6|7|2B|8|@]|9|@]|C|$]]]|1D|$1E|$5|1F|1G|1H|C|$1I|1J]]]]

<a href="http://en.wikipedia.org/wiki/Isolation_%28database_systems%29#Non-repeatable_reads" rel="noreferrer">From Wikipedia</a> (which has great and detailed examples for this):

<blockquote>
 A non-repeatable read occurs, when during the course of a transaction, a row is retrieved twice and the values within the row differ between reads.
</blockquote>

and

<blockquote>
 A phantom read occurs when, in the course of a transaction, two identical queries are executed, and the collection of rows returned by the second query is different from the first.
</blockquote>

Simple examples:

<ul>
<li>User A runs the same query twice. </li>
<li>In between, User B runs a transaction and commits.</li>
<li>Non-repeatable read: The A row that user A has queried has a different value the second time.</li>
<li>Phantom read: All the rows in the query have the same value before and after, but different rows are being selected (because B has deleted or inserted some). Example: <code>select sum(x) from table;</code> will return a different result even if none of the affected rows themselves have been updated, if rows have been added or deleted.</li>
</ul>

<blockquote>
 In the above example,which isolation level to be used?
</blockquote>

What isolation level you need depends on your application. There is a high cost to a "better" isolation level (such as reduced concurrency).

In your example, you won't have a phantom read, because you select only from a single row (identified by primary key). You can have non-repeatable reads, so if that is a problem, you may want to have an isolation level that prevents that. In Oracle, transaction A could also issue a SELECT FOR UPDATE, then transaction B cannot change the row until A is done.

blocks|key|2877205|text|我喜欢用一种简单的方式来思考它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2877206|不可重复读取和幻影读取都与来自不同事务的数据修改操作有关，这些操作是在事务开始后提交的，然后由事务读取。|2877207|不可重复读取是指您的事务从另一个事务读取已提交的更新。同一行现在具有不同于事务开始时的值。|offset|length|style|BOLD|2877208|幻影读取是类似的，但是当从提交的读取时，插入和/或从另一个事务中删除。有一个或多个新行在您开始事务后消失了。|2877209|脏读与不可重复读和幻影读类似，但与读取未提交的数据有关，当从另一个事务读取更新、插入或删除，而另一个事务尚未提交数据时，就会发生脏读。它正在读取“正在进行”的数据，这些数据可能不完整，也可能永远不会被提交。|2877210|entityMap^0|0|0|O|2|0|G|6|P|9|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@$F|S|G|T|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@$F|V|G|W|H|I]|$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|O|$]]

A simple way I like to think about it is: 

Both non-repeatable and phantom reads have to do with data modification operations from a different transaction, which were committed after your transaction began, and then read by your transaction.

Non-repeatable reads are when your transaction reads committed UPDATES from another transaction. The same row now has different values than it did when your transaction began.

Phantom reads are similar but when reading from committed INSERTS and/or DELETES from another transaction. There are new rows or rows that have disappeared since you began the transaction.

Dirty reads are similar to non-repeatable and phantom reads, but relate to reading UNCOMMITTED data, and occur when an UPDATE, INSERT, or DELETE from another transaction is read, and the other transaction has NOT yet committed the data. It is reading "in progress" data, which may not be complete, and may never actually be committed.

blocks|key|224539|text|这两种隔离级别在实现上存在差异。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|224540|对于“不可重复读”，需要行锁定。|224541|对于"phantom+read“，需要作用域锁定，甚至是表锁。|224542|我们可以使用two-phase-locking协议来实现这两个层次。|offset|length|224543|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Two-phase_locking^0|0|0|0|6|H|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

There is a difference in the implementation between these two kinds isolation levels. 
For "non-repeatable read", row-locking is needed. 
For "phantom read"，scoped-locking is needed, even a table-locking. 
We can implement these two levels by using <a href="http://en.wikipedia.org/wiki/Two-phase_locking" rel="noreferrer">two-phase-locking</a> protocol.

blocks|key|224564|text|公认的答案最重要的是，这两者之间的所谓区别实际上并不重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|224565|如果“一行被检索两次，并且行中的值在读取之间不同”，则它们不是同一行(在正确的RDB中不是相同的元组)，那么根据定义，确实也是这样的：“由第二个查询返回的行集合与第一个不同”。|224566|至于“应该使用哪个隔离级别”的问题，你的数据对某人越重要，在某个地方，串行化就越有可能是你唯一合理的选择。|224567|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The accepted answer indicates most of all that the so-called distinction between the two is actually not significant at all.

If "a row is retrieved twice and the values within the row differ between reads", then they are not the same row (not the same tuple in correct RDB speak) and it is then indeed by definition also the case that "the collection of rows returned by the second query is different from the first".

As to the question "which isolation level should be used", the more your data is of vital importance to someone, somewhere, the more it will be the case that Serializable is your only reasonable option.

blocks|key|2877438|text|Read+phenomena|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2877439|2877440|Dirty读取：从另一个事务读取未提交的数据读取：从另一个事务读取UPDATE查询中的已提交数据读取：从另一个事务中读取INSERT或DELETE查询中的已提交数据|unordered-list-item|style|BOLD|CODE|2877441|2877442|注释：在某些情况下，从另一个事务中删除语句导致不可重复读取的可能性也非常低。不幸的是，当DELETE语句删除了当前事务正在查询的同一行时，就会发生这种情况。但这是一种罕见的情况，而且在每个表中都有数百万行的数据库中发生的可能性更小。在任何生产环境中，包含事务数据的表通常都有很大的数据量。|2877443|此外，我们可以观察到，在大多数用例中，更新可能是更频繁的作业，而不是实际的插入或删除(在这种情况下，只有不可重复读取的危险-在这些情况下，幻影读取是不可能的)。这就是为什么更新与INSERT-DELETE的处理方式不同，所产生的异常的名称也不同。|2877444|处理插入-删除操作，而不仅仅是处理更新操作，还会带来额外的处理成本。|2877445|​|2877446|不同的优势|2877447|2877448|READ_UNCOMMITTED不会阻止任何事情。它的零隔离level|2877449|READ_COMMITTED仅防止一个异常，即脏reads|2877450|REPEATABLE_READ防止两个异常:脏读取和不可重复reads|2877451|SERIALIZABLE防止所有三个异常:脏读取、不可重复读取和幻象读取|2877452|2877453|那么为什么不直接设置事务SERIALIZABLE呢？好吧，上面问题的答案是:+SERIALIZABLE设置使事务非常慢，这也是我们不想要的。|2877454|事实上，事务时间消耗的比率如下：|2877455|2877456|+SERIALIZABLE+>+REPEATABLE_READ+>+READ_COMMITTED+>+READ_UNCOMMITTED|blockquote|2877457|2877458|2877459|所以READ_UNCOMMITTED设置是最快的。|2877460|2877461|摘要|2877462|实际上，我们需要分析用例并确定隔离级别，以便优化事务时间并防止大多数异常。|2877463|请注意，默认情况下，数据库可能具有REPEATABLE_READ设置。管理员和架构师可能会倾向于选择此设置作为默认设置，以展示更好的平台性能。|2877464|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Isolation_(database_systems)#Read_phenomena^0|0|E|0|0|0|0|7|X|6|1O|6|1V|6|0|0|0|2|0|0|0|0|0|0|0|0|0|0|0|0|0|0|E|1|W|1|1D|1|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1W|8|@]|9|@$A|1X|B|1Y|1|1Z]]|C|$]]|$1|D|3|-4|5|6|7|20|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|21|8|@$A|22|B|23|H|I]|$A|24|B|25|H|J]|$A|26|B|27|H|J]|$A|28|B|29|H|J]]|9|@]|C|$]]|$1|K|3|-4|5|6|7|2A|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|2B|8|@$A|2C|B|2D|H|I]]|9|@]|C|$]]|$1|N|3|O|5|6|7|2E|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|2F|8|@]|9|@]|C|$]]|$1|R|3|S|5|6|7|2G|8|@]|9|@]|C|$]]|$1|T|3|U|5|6|7|2H|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|2I|8|@]|9|@]|C|$]]|$1|W|3|X|5|G|7|2J|8|@]|9|@]|C|$]]|$1|Y|3|Z|5|G|7|2K|8|@]|9|@]|C|$]]|$1|10|3|11|5|G|7|2L|8|@]|9|@]|C|$]]|$1|12|3|13|5|G|7|2M|8|@]|9|@]|C|$]]|$1|14|3|-4|5|6|7|2N|8|@]|9|@]|C|$]]|$1|15|3|16|5|6|7|2O|8|@]|9|@]|C|$]]|$1|17|3|18|5|6|7|2P|8|@]|9|@]|C|$]]|$1|19|3|-4|5|6|7|2Q|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|1C|7|2R|8|@$A|2S|B|2T|H|I]|$A|2U|B|2V|H|I]|$A|2W|B|2X|H|I]]|9|@]|C|$]]|$1|1D|3|-4|5|6|7|2Y|8|@]|9|@]|C|$]]|$1|1E|3|-4|5|6|7|2Z|8|@]|9|@]|C|$]]|$1|1F|3|1G|5|6|7|30|8|@]|9|@]|C|$]]|$1|1H|3|S|5|6|7|31|8|@]|9|@]|C|$]]|$1|1I|3|1J|5|6|7|32|8|@]|9|@]|C|$]]|$1|1K|3|1L|5|6|7|33|8|@]|9|@]|C|$]]|$1|1M|3|1N|5|6|7|34|8|@]|9|@]|C|$]]|$1|1O|3|-4|5|6|7|35|8|@]|9|@]|C|$]]]|1P|$1Q|$5|1R|1S|1T|C|$1U|1V]]]]

<h2><a href="https://en.wikipedia.org/wiki/Isolation_(database_systems)#Read_phenomena" rel="noreferrer">Read phenomena</a></h2>
<ul>
<li>Dirty reads: read UNCOMMITED data from another transaction</li>
<li>Non-repeatable reads: read COMMITTED data from an <code>UPDATE</code> query from another transaction</li>
<li>Phantom reads: read COMMITTED data from an <code>INSERT</code> or <code>DELETE</code> query from another transaction</li>
</ul>
Note : DELETE statements from another transaction, also have a very low probability of causing Non-repeatable reads in certain cases. It happens when the DELETE statement unfortunately, removes the very same row which your current transaction was querying. But this is a rare case, and far more unlikely to occur in a database which have millions of rows in each table. Tables containing transaction data usually have high data volume in any production environment.
Also we may observe that UPDATES may be a more frequent job in most use cases rather than actual INSERT or DELETES (in such cases, danger of non-repeatable reads remain only - phantom reads are not possible in those cases). This is why UPDATES are treated differently from INSERT-DELETE and the resulting anomaly is also named differently.
There is also an additional processing cost associated with handling for INSERT-DELETEs, rather than just handling the UPDATES.
 
<h2>Benefits of different <a href="https://en.wikipedia.org/wiki/Isolation_(database_systems)#Isolation_levels" rel="noreferrer">isolation levels</a></h2>
<ul>
<li>READ_UNCOMMITTED prevents nothing. It's the zero
isolation level</li>
<li>READ_COMMITTED prevents just one, i.e. Dirty reads</li>
<li>REPEATABLE_READ prevents two anomalies: Dirty reads and
Non-repeatable reads</li>
<li>SERIALIZABLE prevents all three anomalies: Dirty reads,
Non-repeatable reads and Phantom reads</li>
</ul>
Then why not just set the transaction SERIALIZABLE at all times? Well, the answer to the above question is: SERIALIZABLE setting makes transactions very slow, which we again don't want.
In fact transaction time consumption is in the following rate:
<blockquote>
SERIALIZABLE &gt; REPEATABLE_READ &gt; READ_COMMITTED &gt; READ_UNCOMMITTED
</blockquote>
So READ_UNCOMMITTED setting is the fastest.
 
<h2>Summary</h2>
Actually we need to analyze the use case and decide an isolation level so that we optimize the transaction time and also prevent most anomalies.
Note that databases by default may have REPEATABLE_READ setting. Admins and architects may have an affinity towards choosing this setting as default, to exhibit better performance of the platform.

blocks|key|2877510|text|我认为不可重复读取和幻影读取之间有一些区别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2877511|不可重复意味着有两个事务A和B。如果B可以注意到A的修改，那么就有可能发生脏读，所以我们让B在A提交后通知A的修改。|2877512|有一个新的问题:我们让B在A提交后通知A的修改，这意味着A修改了B持有的行的值，有时B会再次读取该行，所以B将获得与第一次不同的新值，我们称之为不可重复的，为了处理这个问题，我们让B在B开始时记住一些东西(因为我还不知道会记住什么)。|2877513|让我们考虑一下新的解决方案，我们可以注意到还有新的问题，因为我们让B记住了一些东西，所以无论A中发生了什么，B都不会受到影响，但是如果B想在表中插入一些数据，而B检查表以确保没有记录，但这些数据是由A插入的，所以可能会发生一些错误。我们称之为Phantom-read。|2877514|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I think there are some difference between Non-repeateable-read &amp; phantom-read.

The Non-repeateable means there are tow transaction A &amp; B. if B can notice the modification of A, so maybe happen dirty-read, so we let B notices the modification of A after A committing.

There is new issue: we let B notice the modification of A after A committing, it means A modify a value of row which the B is holding, sometime B will read the row again, so B will get new value different with first time we get, we call it Non-repeateable, to deal with the issue, we let the B remember something(cause i don't know what will be remembered yet) when B start.

Let's think about the new solution, we can notice there is new issue as well, cause we let B remember something, so whatever happened in A, the B can't be affected, but if B want to insert some data into table and B check the table to make sure there is no record, but this data has been inserted by A, so maybe occur some error. We call it Phantom-read.

blocks|key|2877629|text|不可重复读取异常如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2877630|​|2877631|📷|atomic|2877632|2877633|重新读取post记录和transactions.|2877634|Bob’s列值为Transactions.|unordered-list-item|2877635|
|2877636|Alice将给定post记录的标题修改为ACID的值。|2877637|2877638|Alice提交她的数据库重新读取post记录，他将观察此表行的不同版本。|2877639|2877640|幻影读取异常可能如下所示：|2877641|2877642|2877643|2877644|2877645|Alice和Bob+start+two数据库transactions.|ordered-list-item|2877646|Bob’s读取与标识符值为1的post行关联的所有post_comment记录。|2877647|Alice添加与标识符值为1的post行关联的新post_comment记录。|2877648|Alice提交她的数据库，重新读取post_comment列值为1的post_id记录，他将观察此结果集的不同版本。|2877649|2877650|因此，当不可重复读取应用于单个行时，幻影读取是关于满足给定查询过滤条件的一系列记录。|2877651|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/679c9668cf8b679ceea0783d8fa619dc.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/f1543a89a8123cf77fee3994437be6e7.png^0|0|6|0|0|0|1|0|0|0|0|0|0|0|0|0|0|0|4|0|0|0|1|1|0|0|0|0|0|0|0|0|4|6|I|4|0^^$0|@$1|2|3|4|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1U|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1V|8|@]|D|@$9|1W|A|1X|1|1Y]]|E|$]]|$1|K|3|G|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|20|8|@]|D|@]|E|$]]|$1|N|3|O|5|P|7|21|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|22|8|@]|D|@]|E|$]]|$1|S|3|T|5|P|7|23|8|@]|D|@]|E|$]]|$1|U|3|R|5|6|7|24|8|@]|D|@]|E|$]]|$1|V|3|W|5|P|7|25|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|26|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|27|8|@$9|28|A|29|B|C]]|D|@]|E|$]]|$1|10|3|G|5|6|7|2A|8|@]|D|@]|E|$]]|$1|11|3|I|5|J|7|2B|8|@]|D|@$9|2C|A|2D|1|2E]]|E|$]]|$1|12|3|G|5|6|7|2F|8|@]|D|@]|E|$]]|$1|13|3|-4|5|6|7|2G|8|@]|D|@]|E|$]]|$1|14|3|15|5|16|7|2H|8|@]|D|@]|E|$]]|$1|17|3|18|5|16|7|2I|8|@]|D|@]|E|$]]|$1|19|3|1A|5|16|7|2J|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|16|7|2K|8|@]|D|@]|E|$]]|$1|1D|3|-4|5|6|7|2L|8|@]|D|@]|E|$]]|$1|1E|3|1F|5|6|7|2M|8|@$9|2N|A|2O|B|C]|$9|2P|A|2Q|B|C]]|D|@]|E|$]]|$1|1G|3|-4|5|6|7|2R|8|@]|D|@]|E|$]]]|1H|$1I|$5|1J|1K|1L|E|$1M|1N|1O|-4]]|1P|$5|1J|1K|1L|E|$1M|1Q|1O|-4]]]]

The Non-Repeatable Read anomaly looks as follows:
<a href="https://vladmihalcea.com/non-repeatable-read/" rel="noreferrer"><img src="https://i.stack.imgur.com/iPI0C.png" alt="Non-Repeatable Read" /></a>
<ol>
<li>Alice and Bob start two database transactions.</li>
<li>Bob’s reads the post record and title column value is Transactions.</li>
<li>Alice modifies the title of a given post record to the value of ACID.</li>
<li>Alice commits her database transaction.</li>
<li>If Bob’s re-reads the post record, he will observe a different version of this table row.</li>
</ol>
The Phantom Read anomaly can happen as follows:
<a href="https://vladmihalcea.com/phantom-read" rel="noreferrer"><img src="https://i.stack.imgur.com/aCtew.png" alt="Phantom Read" /></a>
<ol>
<li>Alice and Bob start two database transactions.</li>
<li>Bob’s reads all the post_comment records associated with the post row with the identifier value of 1.</li>
<li>Alice adds a new post_comment record which is associated with the post row having the identifier value of 1.</li>
<li>Alice commits her database transaction.</li>
<li>If Bob’s re-reads the post_comment records having the post_id column value equal to 1, he will observe a different version of this result set.</li>
</ol>
So, while the Non-Repeatable Read applies to a single row, the Phantom Read is about a range of records which satisfy a given query filtering criteria.

blocks|key|226932|text|不可重复读取是一种隔离级别，而幻影读取(由其他事务读取提交的值)是一个概念(读取类型，例如脏读取或快照读取)。不可重复读取隔离级别允许幻影读取，但不允许脏读取或快照读取。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|226933|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

non-repeatable read is an isolation level and phantom read (reading committed value by other transactions) is a concept (type of read e.g. dirty read or snapshot read). Non-repeatable read isolation level allows phantom read but not dirty reads or snapshot reads.

blocks|key|3091661|text|不可重复读取和幻影读取都是由于一个事务T1看到来自另一个事务T2的更改而导致的，该事务在T1完成之前提交。不同之处在于，不可重复读取为同一逻辑行返回不同的值。(例如，如果主键是employee_id，那么在两个结果中，某个员工的薪水可能不同。)幻影读取返回两个不同的行集，但是对于出现在这两个集中的每一行，列值都是相同的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3091662|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Both non-repeatable reads and phantom reads result from one transaction T1 seeing changes from another transaction T2 that commits before T1 is complete. The difference is that a non-repeatable read returns different values for the same logical row. (For example, if the primary key is employee_id, then a certain employee may have different salaries in the two results.) A phantom read returns two different sets of rows, but for every row that appears in both sets, the column values are the same.

What is the difference between non-repeatable read and phantom read?

I have read the <a href="http://en.wikipedia.org/wiki/Isolation_(database_systems)" rel="noreferrer">Isolation (database systems) article from Wikipedia</a>, but I have a few doubts. In the below example, what will happen: the non-repeatable read and phantom read?

Transaction A

<pre><code>SELECT ID, USERNAME, accountno, amount FROM USERS WHERE ID=1
</code></pre>

OUTPUT:

<pre><code>1----MIKE------29019892---------5000
</code></pre>

Transaction B

<pre><code>UPDATE USERS SET amount=amount+5000 where ID=1 AND accountno=29019892;
COMMIT;
</code></pre>

Transaction A

<pre><code>SELECT ID, USERNAME, accountno, amount FROM USERS WHERE ID=1
</code></pre>

Another doubt is, in the above example, which isolation level should be used? And why?

What is the difference between Non-Repeatable Read and Phantom Read?

数据库

不可重复读取和幻影读取之间的区别是什么？我已经阅读了，但我有一些疑问。在下面的示例中，将会发生什么：不可重复读取和幻象读取事务ASELECT ID, USERNAME, accountno, amount FROM USERS WHERE ID=1输出：1----MIKE------29019892---------5...

问不可重复读取和幻影读取之间的区别是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问不可重复读取和幻影读取之间的区别是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问不可重复读取和幻影读取之间的区别是什么？
EN