脏读 订阅
脏读又称无效数据的读出,是指在数据库访问中,事务T1将某一值修改,然后事务T2读取该值,此后T1因为某种原因撤销对该值的修改,这就导致了T2所读取到的数据是无效的,值得注意的是,脏读一般是针对于update操作的。 展开全文
脏读又称无效数据的读出,是指在数据库访问中,事务T1将某一值修改,然后事务T2读取该值,此后T1因为某种原因撤销对该值的修改,这就导致了T2所读取到的数据是无效的,值得注意的是,脏读一般是针对于update操作的。
信息
别    称
无效数据的读出
出    处
sql语句
拼    音
zang du
中文名
脏读
外文名
Read out of invalid data
网络规划规划设计
脏读就是指当一个事务正在访问数据,并且对数据进行了修改,而这种修改还没有提交到数据库中,这时,另外一个事务也访问这个数据,然后使用了这个数据。因为这个数据是还没有提交的数据,那么另外一个事务读到的这个数据是脏数据,依据脏数据所做的操作可能是不正确的。
收起全文
精华内容
下载资源
问答
  • 脏读

    千次阅读 2019-02-18 23:36:33
    脏读: 对于对象的同步和异步的方法,我们在设计自己的程序的时候,一定要考虑问题的整体,不然就会出现数据不一致的错误,很经典的就是脏读(dirtyread)。 public class DirtyRead { private String username = ...

    脏读:
    对于对象的同步和异步的方法,我们在设计自己的程序的时候,一定要考虑问题的整体,不然就会出现数据不一致的错误,很经典的就是脏读(dirtyread)。

    public class DirtyRead {
    
    	private String username = "li4";
    	private String password = "123";
    	
    	public void setValue(String username,String password){
    		this.username = username;
    		
    		try {
    			Thread.sleep(2000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		
    		this.password = password;
    		
    		System.out.println("setValue的最终结果: username=" + this.username + ",password=" + this.password);
    	}
    	
    	public void getValue(){
    		System.out.println("getValue的最终结果: username=" + this.username + ",password=" + this.password);
    	}
    	
    	public static void main(String args[]) throws InterruptedException{
    		
    		final DirtyRead dr = new DirtyRead();
    		
    		Thread t1 = new Thread(new Runnable(){
    			@Override
    			public void run() {
    				dr.setValue("z3", "456");
    			}
    			
    		});
    		
    		t1.start();
    		Thread.sleep(1000);
    		dr.getValue();
    	}
    }
    

    输出结果:

    getValue的最终结果: username=z3,password=123
    setValue的最终结果: username=z3,password=456
    

    分析:
    示例中有两个线程,一个主线程,一个主线程中的小线程,主线程会一直往下执行,在t1.start()时,小线程执行到dr.setValue()里会有2秒的等待,此时z3已经赋值给了username,在小线程等待的过程中,主程序会继续往下执行,等待了一秒后会调用dr.getValue()里的内容,即输出的第一行,随后小程序2秒的睡眠完成后,继续把456赋值给password,输出第二行的内容。我赋值的明明是z3,456,而输出的getValue()是z3,123,由此就造成了脏读现象。

    改进:
    在这里插入图片描述
    输出结果:

    setValue的最终结果: username=z3,password=456
    getValue的最终结果: username=z3,password=456
    

    分析:
    在setValue()和getValue()中加了synchronized关键字同步,当t1小线程进入到setValue()里时,主线程想要进入加了synchronized关键字的getValue()就要等t1小线程执行完它的代码释放了锁,主线程才能进入getValue()。

    示例总结:

    在我们对一个对象的方法加锁的时候,需要考虑业务的整体性,即为setValue/getValue方法同时加锁synchronized同步关键字,保证业务(service)的原子性,不然会出现业务错误(也从侧面保证业务的一致性)。

    展开全文
  • 【数据库】快速理解脏读、不可重复读、幻读

    万次阅读 多人点赞 2018-08-14 19:24:29
    快速理解脏读、不可重复读、幻读? 理解这三种由于并发访问导致的数据读取问题,再理解事务隔离级别就简单多了。 【1】脏读(读取未提交数据) A事务读取B事务尚未提交的数据,此时如果B事务发生错误并执行...

                                 快速理解脏读、不可重复读、幻读?

     

    理解这三种由于并发访问导致的数据读取问题,再理解事务隔离级别就简单多了。

     

    【1】脏读(读取未提交数据

    A事务读取B事务尚未提交的数据,此时如果B事务发生错误并执行回滚操作,那么A事务读取到的数据就是脏数据。就好像原本的数据比较干净、纯粹,此时由于B事务更改了它,这个数据变得不再纯粹。这个时候A事务立即读取了这个脏数据,但事务B良心发现,又用回滚把数据恢复成原来干净、纯粹的样子,而事务A却什么都不知道,最终结果就是事务A读取了此次的脏数据,称为脏读。

    这种情况常发生于转账与取款操作中

    时间顺序

    转账事务

    取款事务

    1

     

    开始事务

    2

    开始事务

     

    3

     

    查询账户余额为2000元

    4

     

    取款1000元,余额被更改为1000元

    5

    查询账户余额为1000元(产生脏读)

     

    6

     

    取款操作发生未知错误,事务回滚,余额变更为2000元

    7

    转入2000元,余额被更改为3000元(脏读的1000+2000)

     

    8

    提交事务

     

    备注

    按照正确逻辑,此时账户余额应该为4000元

     

     

    【2】不可重复读(前后多次读取,数据内容不一致

    事务A在执行读取操作,由整个事务A比较大,前后读取同一条数据需要经历很长的时间 。而在事务A第一次读取数据,比如此时读取了小明的年龄为20岁,事务B执行更改操作,将小明的年龄更改为30岁,此时事务A第二次读取到小明的年龄时,发现其年龄是30岁,和之前的数据不一样了,也就是数据不重复了,系统不可以读取到重复的数据,成为不可重复读。

    时间顺序

    事务A

    事务B

    1

    开始事务

     

    2

    第一次查询,小明的年龄为20岁

     

    3

     

    开始事务

    4

    其他操作

     

    5

     

    更改小明的年龄为30岁

    6

     

    提交事务

    7

    第二次查询,小明的年龄为30岁

     

    备注

    按照正确逻辑,事务A前后两次读取到的数据应该一致

     

     

    【3】幻读(前后多次读取,数据总量不一致

    事务A在执行读取操作,需要两次统计数据的总量,前一次查询数据总量后,此时事务B执行了新增数据的操作并提交后,这个时候事务A读取的数据总量和之前统计的不一样,就像产生了幻觉一样,平白无故的多了几条数据,成为幻读。

    时间顺序

    事务A

    事务B

    1

    开始事务

     

    2

    第一次查询,数据总量为100条

     

    3

     

    开始事务

    4

    其他操作

     

    5

     

    新增100条数据

    6

     

    提交事务

    7

    第二次查询,数据总量为200条

     

    备注

    按照正确逻辑,事务A前后两次读取到的数据总量应该一致


    趁热打铁,既然理解了脏读、不可重复读、幻读,那么接下来看看事务隔离级别是怎么个回事【数据库】事务隔离级别

    不可

     

    展开全文
  • 什么是脏读不可重复读幻影读,JAVA程序对MYSQL数据库加锁实验
  • 事务隔离级别脏读幻读 In this article, we will discuss the Dirty Read concurrency issue and also learn the details of the Read Uncommitted Isolation Level. 在本文中,我们将讨论“ 脏读”并发问题,...

    事务隔离级别脏读幻读

    In this article, we will discuss the Dirty Read concurrency issue and also learn the details of the Read Uncommitted Isolation Level.

    在本文中,我们将讨论“ 脏读”并发问题,并了解“ 读未提交的隔离级别”的详细信息。

    A transaction is the smallest working unit that performs the CRUD (Create, Read, Update, and Delete) actions in the relational database systems. Relevant to this matter, database transactions must have some characteristics to provide database consistency. The following four features constitute the major principles of the transactions to ensure the validity of data stored by database systems. These are;

    事务是在关系数据库系统中执行CRUD(创建,读取,更新和删除)操作的最小工作单元。 与此相关的是,数据库事务必须具有某些特性以提供数据库一致性。 以下四个功能构成了事务的主要原理,以确保数据库系统存储的数据的有效性。 这些是;

    • Atomicity 一个 tomicity
    • Consistency çonsistency
    • Isolation 我这样
    • Durability d urability

    These four properties are also known as ACID principles. Let’s briefly explain these four principles.

    这四个属性也称为ACID原理。 让我们简要解释这四个原则。

    原子性 (Atomicity )

    This property is also known as all or nothing principle. According to this property, a transaction can not be completed partially, so if a transaction gets an error at any point of the transaction, the entire transaction should be aborted and rollbacked. Or, all the actions contained by a transaction must be completed successfully.

    此属性也称为“全部或全部”原则。 根据此属性,不能部分完成事务,因此,如果事务在事务的任何点出现错误,则应中止并回滚整个事务。 或者,必须成功完成事务包含的所有操作。

    一致性 (Consistency )

    According to this property, the saved data must not damage data integrity. This means that the modified data must provide the constraints and other requirements that are defined in the database.

    根据此属性,保存的数据不得破坏数据完整性。 这意味着修改后的数据必须提供数据库中定义的约束和其他要求。

    耐用性 (Durability)

    According to this property, the committed will not be lost even with the system or power failure.

    根据此属性,即使系统或电源出现故障,提交的内容也不会丢失。

    隔离 (Isolation )

    The database transactions must complete their tasks independently from the other transactions. This property enables us to execute the transactions concurrently on the database systems. So, the data changes which are made up by the transactions are not visible until the transactions complete (committed) their actions. The SQL standard describes three read phenomena, and they can be experienced when more than one transaction tries to read and write to the same resources.

    数据库事务必须独立于其他事务完成其任务。 此属性使我们能够在数据库系统上并发执行事务。 因此,在事务完成(提交)其操作之前,由事务构成的数据更改是不可见的。 SQL标准描述了三种读取现象,当多个事务尝试读取和写入相同的资源时可能会遇到这种现象。

    • Dirty-reads

      脏读
    • Non-repeatable reads

      不可重复读
    • Phantom reads

      幻影阅读

    什么是脏读? (What is Dirty Read?)

    The simplest explanation of the dirty read is the state of reading uncommitted data. In this circumstance, we are not sure about the consistency of the data that is read because we don’t know the result of the open transaction(s). After reading the uncommitted data, the open transaction can be completed with rollback. On the other hand, the open transaction can complete its actions successfully. The data that is read in this ambiguous way is defined as dirty data. Now we will explain this issue with a scenario:

    脏读取的最简单解释是读取未提交数据的状态。 在这种情况下,我们不确定所读取数据的一致性,因为我们不知道未完成交易的结果。 读取未提交的数据后,可以通过回滚完成未完成的事务。 另一方面,未清事务可以成功完成其操作。 以这种歧义方式读取的数据被定义为脏数据。 现在,我们将用一个场景来解释这个问题:

    Assuming we have a table as shown below that stores the bank account details of the clients.

    假设我们有一个下表,该表存储了客户的银行帐户详细信息。

    AccountNumber

    ClientName

    Balance

    7Y290394

    Betty H. Bonds

    $78.00

    账号

    客户名称

    平衡

    7Y290394

    贝蒂·H·邦兹

    $ 78.00

    In this scenario, Betty has $78.00 in her bank account, and the automatic payment system withdraws $45 from Betty’s account for the electric bill. At that time, Betty wants to check her bank account on the ATM, and she notices $33 in her bank account. However, if the electric bill payment transaction is rollbacked for any reason, the bank account balance will be turned to $78.00 again, so the data read by Betty is dirty data. In this case, Betty will be confused. The following diagram illustrates this dirty read scenario in a clearer manner.

    在这种情况下,Betty的银行帐户有$ 78.00,自动付款系统会从Betty的帐户中提取$ 45的电费。 当时,贝蒂想在自动柜员机上检查她的银行帐户,她发现自己的银行帐户中有33美元。 但是,如果由于任何原因而回扣了电费支付交易,则银行帐户余额将再次变为$ 78.00,因此Betty读取的数据是肮脏的数据。 在这种情况下,贝蒂会感到困惑。 下图以更清晰的方式说明了这种脏读情况。

    Read uncommitted isolation level explanation diagram.

    Now we will realize this scenario in practice with SQL Server. Firstly we will create the BankDetailTbl table that stores the bank account details of the clients.

    现在,我们将在SQL Server的实践中实现这种情况。 首先,我们将创建BankDetailTbl表,该表存储客户的银行帐户详细信息。

    CREATE TABLE BankDetailTbl
    (
      Id            INT
      PRIMARY KEY IDENTITY(1, 1), 
      AccountNumber VARCHAR(40), 
      ClientName    VARCHAR(100), 
      Balance       MONEY);
    

    As a second step, we will insert a sample row to it.

    第二步,我们将在其中插入一个示例行。

    INSERT INTO BankDetailTbl
    VALUES
    ('7Y290394', 'Betty H. Bonds', '78');
    

    Now we will execute the following queries, the Query-1 updates the balance value of the particular bank account, and then it will wait 20 seconds and rollback the data modification. At this moment, we will immediately execute the Query-2, and this query reads the modified but uncommitted data.

    现在,我们将执行以下查询,Query-1更新特定银行帐户的余额值,然后将等待20秒并回滚数据修改。 此时,我们将立即执行Query-2,此查询将读取已修改但未提交的数据。

    Query-1:

    查询1:

    BEGIN TRAN;
    UPDATE BankDetailTbl
    SET 
        Balance=Balance-45
    WHERE AccountNumber = '7Y290394';
    WAITFOR DELAY '00:00:20';
    ROLLBACK TRAN;
     
    SELECT *
    FROM BankDetailTbl
    WHERE AccountNumber = '7Y290394';
    

    Query-2:

    查询2:

    SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
    BEGIN TRAN;
    SELECT *
    FROM BankDetailTbl
    WHERE AccountNumber = '7Y290394';
    COMMIT TRAN;
    

    SQL Server dirty read example.

    As a result, the data read by Query-2 was dirty because the data was returned to its first state because of the rollback process.

    结果,由于回滚过程使数据返回到其第一状态,因此Query-2读取的数据很脏。

    读未提交与读提交隔离级别 (The Read Uncommitted vs Read Committed Isolation Level)

    As we explained, a transaction must be isolated from other transactions according to the isolation property of the ACID transactions. In this context, isolation levels specify the isolation strategy of a transaction from the other transactions.

    正如我们所解释的,必须根据ACID事务的隔离属性将一个事务与其他事务隔离。 在这种情况下, 隔离级别指定一个事务与其他事务的隔离策略。

    什么是排他锁? (What is Exclusive Lock?)

    By default, SQL Server sets an exclusive lock for data that is being modified to ensure data consistency until the transaction is complete. So, it isolates the modified data from the other transaction.

    默认情况下,SQL Server为正在修改的数据设置排他锁,以确保数据一致性,直到事务完成为止。 因此,它将修改后的数据与其他事务隔离。

    Read uncommitted is the weakest isolation level because it can read the data which are acquired exclusive lock to the resources by the other transactions. So, it might help to avoid locks and deadlock problems for the data reading operations. On the other hand, Read Committed can not read the resource that acquires an exclusive lock, and this is the default level of the SQL Server.

    读取未提交是最弱的隔离级别,因为它可以读取通过其他事务获得的对资源的独占锁定的数据。 因此,这可能有助于避免数据读取操作的锁定和死锁问题。 另一方面, Read Committed无法读取获得排他锁的资源,这是SQL Server的默认级别。

    Now we will work on an example of this difference to figure this out. With the help of the Query-3, we will change the ClientName column value of a client. During this time, Query-4 tries to read the same client details, but Query-4 could not be read the data until the Query-3 completes the update action. At first, we will execute the Query-3.

    现在,我们将研究这种差异的一个例子,以解决这一问题。 借助Query-3,我们将更改客户端的ClientName列值。 在此期间,Query-4尝试读取相同的客户端详细信息,但是直到Query-3完成更新操作之前,Query-4才能读取数据。 首先,我们将执行Query-3。

    Query-3:

    查询3:

    BEGIN TRAN;
    UPDATE BankDetailTbl
    SET 
        ClientName='Doris P. Barnum'
    WHERE AccountNumber = '7Y290394';
    WAITFOR DELAY '00:00:50'
    ROLLBACK TRAN
    

    After executing the Query-3, we are executing the Query-4 immediately on another query window at this moment.

    执行完Query-3之后,我们现在正在另一个查询窗口上立即执行Query-4。

    Query-4:

    查询4:

    DECLARE @TimeDiff AS INT
    DECLARE @BegTime AS DATETIME
    DECLARE @EndTime AS DATETIME
    BEGIN TRAN
    SET @BegTime = GETDATE()
    SELECT ClientName FROM BankDetailTbl 
    WHERE AccountNumber = '7Y290394';
    SET @EndTime = GETDATE()
    SET @TimeDiff = DATEDIFF(SECOND,@EndTime,@BegTime)
    SELECT @TimeDiff AS QueryCompletionTime
    COMMIT TRAN
    

    Comparing SQL Server Read Uncommitted vs Read Committed Isolation Level.

    In Query-4, we have measured the query completion time, and the @TimeDiff variable indicates this measured time. As we have seen, Query-4 has completed on 49 seconds because it has waited for the completion of the Query-3 because the Read Committed level does not allow dirty reads. Now we will change this level to Read Uncommitted for Query-4. SET TRANSACTION ISOLATION LEVEL statement helps to explicitly change the isolation level for a transaction. We will execute the Query-3 and Query-4 at the same order and will observe the result.

    在查询4中, 我们 已测量查询完成时间, @ TimeDiff变量指示此测量时间。 正如我们所看到的,Query-4之所以完成了49秒,是因为它等待Query-3的完成,因为Read Committed级别不允许脏读。 现在,我们将把此级别更改为对Query-4的读取未提交SET TRANSACTION ISOLATION LEVEL语句有助于显式更改事务的隔离级别。 我们将以相同的顺序执行Query-3和Query-4,并将观察结果。

    Query-3:

    查询3:

    BEGIN TRAN;
    UPDATE BankDetailTbl
    SET 
        ClientName='Doris P. Barnum'
    WHERE AccountNumber = '7Y290394';
    WAITFOR DELAY '00:00:50'
    ROLLBACK TRAN
    

    Query-4:

    查询4:

    DECLARE @TimeDiff AS INT
    DECLARE @BegTime AS DATETIME
    DECLARE @EndTime AS DATETIME
    BEGIN TRAN
    SET @BegTime = GETDATE()
    SELECT ClientName FROM BankDetailTbl 
    WHERE AccountNumber = '7Y290394';
    SET @EndTime = GETDATE()
    SET @TimeDiff = DATEDIFF(SECOND,@EndTime,@BegTime)
    SELECT @TimeDiff AS QueryCompletionTime
    COMMIT TRAN
    

    Dirty read and isolation levels interaction

    As we can see, the Query-4 did not wait for the completion of the Query-3 and completed as soon as possible.

    如我们所见,Query-4没有等待Query-3的完成,而是尽快完成。

    分配顺序扫描和读取未提交的隔离级别 (Allocation Order Scans and Read Uncommitted Isolation Level)

    In this section, we will discuss an internal secret of the query execution mechanism of the SQL Server. At first, we will execute the following query in the AdventureWorks2017 sample database.

    在本节中,我们将讨论SQL Server查询执行机制的内部秘密。 首先,我们将在AdventureWorks 2017示例数据库中执行以下查询。

    CHECKPOINT;
    DBCC DROPCLEANBUFFERS;
    GO
    BEGIN TRAN
    SELECT WorkOrderID, 
           StartDate, 
           EndDate
    FROM Production.WorkOrder; 
    COMMIT TRAN
    

    These query results are sorted by the WorkOrderId column.

    这些查询结果按WorkOrderId列排序。

    Index order scan example

    Now, we will change the isolation and execute the same query on another query window. However, the result is slightly different than we expected because of the WorkOrderID column sort.

    现在,我们将更改隔离,并在另一个查询窗口上执行相同的查询。 但是,由于WorkOrderID列的排序,结果与我们预期的略有不同。

    CHECKPOINT;
    DBCC DROPCLEANBUFFERS;
    GO
    SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED
    BEGIN TRAN
    SELECT WorkOrderID, 
           StartDate, 
           EndDate
    FROM Production.WorkOrder; 
    COMMIT TRAN
    

    Allocation order scan  example

    When we compare the execution plans of these two queries, we could not find any logical difference between them.

    当我们比较这两个查询的执行计划时,我们找不到它们之间的任何逻辑差异。

    SQL Server execution plan compare

    In the execution plan, if we look at the clustered index scan operator Ordered attribute, it shows the “False” value.

    在执行计划中,如果我们查看聚簇索引扫描运算符Ordered属性,它将显示“ False”值。

    Clustered index scan properties

    In this case, the storage engine has two options for accessing the data. The first one is an index order scan that uses the B-tree index structure. The second option is an allocation order scan, and it uses the Index Allocation Map (IAM) and performs the scan in the physical allocation order.

    在这种情况下,存储引擎有两个用于访问数据的选项。 第一个是使用B树索引结构的索引顺序扫描 。 第二个选项是分配顺序扫描,它使用索引分配图(IAM)并按照物理分配顺序执行扫描。

    Allocation order scans can be considered by the database engine when the following reason meets because we don’t care about the data read data consistency.

    当满足以下原因时,数据库引擎可以考虑分配顺序扫描,因为我们不在乎数据读取数据的一致性。

    • The index size is greater than 64 pages

      索引大小大于64页
    • NOLOCK hint NOLOCK提示运行
    • The Ordered attribute of the Index Scan operator is false

      索引扫描运算符的Ordered属性为false

    Tip: Allocation order scans can be performed when we use the TABLOCK hint in a query.

    提示:当我们在查询中使用TABLOCK提示时,可以执行分配顺序扫描。

    CHECKPOINT;
    DBCC DROPCLEANBUFFERS;
    GO
    BEGIN TRAN
    SELECT WorkOrderID, 
           StartDate, 
           EndDate
    FROM Production.WorkOrder  WITH(TABLOCK); 
    COMMIT TRAN
    

    TABLOCK  hint and allocation order scan

    结论 (Conclusion)

    In this article, we discussed the dirty read issue and also explained the Read Uncommitted Isolation Level differences. This level has its own characteristics, so when you decide to use it, we need to take into account lock, data consistency, and other issues. At the same time, we also explored the allocation order scan data access method and details.

    在本文中,我们讨论了脏读问题,并解释了读未提交隔离级别的差异。 此级别具有其自身的特征,因此当您决定使用它时,我们需要考虑锁定,数据一致性和其他问题。 同时,我们还探讨了分配顺序扫描数据的访问方法和细节。

    翻译自: https://www.sqlshack.com/dirty-reads-and-the-read-uncommitted-isolation-level/

    事务隔离级别脏读幻读

    展开全文
  • 本篇文章小编将为大家介绍,.NET中 关于脏读 不可重复读与幻读的代码示例,有需要的朋友可以参考一下
  • 脏读,不可重复读,幻读区别和避免

    万次阅读 2020-03-27 14:28:06
    在了解脏读,不可重复度,幻读之前,首先要明白这三种情况的出现都是和数据库并发事务有关联的,如果所有的读写都按照队列的形式进行,就不会出现问题。 名词解析和解决方案 脏读 脏读又称无效数据读出(读出了脏...

    在了解脏读,不可重复度,幻读之前,首先要明白这三种情况的出现都是和数据库并发事务有关联的,如果所有的读写都按照队列的形式进行,就不会出现问题。

    名词解析和解决方案

    脏读

    脏读又称无效数据读出(读出了脏数据)。一个事务读取另外一个事务还没有提交的数据叫脏读。

    例如:事务T1修改了某个表中的一行数据,但是还没有提交,这时候事务T2读取了被事务T1修改后的数据,之后事务T1因为某种原因回滚(Rollback)了,那么事务T2读取的数据就是脏的(无效的)。

    解决办法:把数据库的事务隔离级别调整到READ_COMMITTED(读提交/不可重复读)

    不可重复读

    不可重复读是指在同一个事务内,两次相同的查询返回了不同的结果。

    例如:事务T1会读取两次数据,在第一次读取某一条数据后,事务T2修改了该数据并提交了事务,T1此时再次读取该数据,两次读取便得到了不同的结果。

    解决办法:把数据库的事务隔离级别调整到REPEATABLE_READ(可重复读)

    幻读

    幻读也是指当事务不独立执行时,插入或者删除另一个事务当前影响的数据而发生的一种类似幻觉的现象。

    例如:系统事务A将数据库中所有数据都删除的时候,但是事务B就在这个时候新插入了一条记录,当事务A删除结束后发现还有一条数据,就好像发生了幻觉一样。这就叫幻读。

    解决办法:把数据库的事务隔离级别调整到SERIALIZABLE_READ(序列化执行),或者数据库使用者自己进行加锁来保证。

    题外话:

    不可重复读出现多是因为修改;幻读重点是新增、删除。mysql中的REPEATABLE_READ模式引入了间隙锁(GAP),解决了幻读的问题。不论是什么方式解决幻读,都会付出一定代价的性能让步。所以说在业务需求和技术方案之间权衡也是技术人员最需要掌握得技能之一。

    展开全文
  • 脏读、幻读、不可重复读

    千次阅读 2017-03-27 09:23:19
    脏读
  • 脏读:读到事务未提交的数据称为脏读,违反事务隔离级别 脏数据:mysql内存页内已发生修改还没有同步到磁盘上的数据,由于mysql是异步按一定频率刷新到磁盘故存在此情况,属于正常 ...
  • 事务里面的脏读、不可重复读、虚读/幻读

    千次阅读 多人点赞 2019-07-17 09:18:00
    脏读 举例演示脏读 脏读就是B事务读取到了A事务尚未提交的数据 ,什么意思呢,往下看 首先执行下面的sql语句 drop table acount; create table acount( id int, name varchar(225), money int ); insert ...
  • 脏读,不可重复读,幻读

    万次阅读 2019-09-20 15:59:43
    脏读,不可重复读,幻读 脏读(Dirty Read) 脏读意味着一个事务读取了另一个事务未提交的数据,而这个数据是有可能回滚。 不可重复读(Unrepeatable Read) 不可重复读意味着,在数据库访问中,一个事务范围内两...
  • JDBC 的脏读是什么?哪种数据库隔离级别能防止脏读脏读:有一行数据刚更新,与此同时另一个查询读到了这个刚更新的值。 TRANSACTIONREPEATABLEREAD 和TRANSACTION_SERIALIZABLE 隔离级别可以防止脏读
  • 数据库的脏读、不可重复读、幻读都和事务的隔离性有关。所以先了解一下事务的4大特性。  事务的4大特性(ACID):  1、原子性(Atomicity):事务是数据库的逻辑工作单位,它对数据库的修改要么全部执行,要么...
  • 脏读,不可重复读,幻读区别

    千次阅读 2018-11-12 09:58:27
    脏读 脏读又称无效数据读出。一个事务读取另外一个事务还没有提交的数据叫脏读。 例如:事务T1修改了一行数据,但是还没有提交,这时候事务T2读取了被事务T1修改后的数据,之后事务T1因为某种原因Rollback了,那么...
  • 一、脏读(读到未提交的数据) 在理解脏读之前,需要理解脏数据的概念。 脏数据是指事务对缓冲池中行记录的修改,并且还没有提交。 注意脏数据和脏页是完全不同的两种概念,脏页指的是在缓冲池中已经被修改的页,...
  • 本文将总结脏读、不可重复读、幻读的概念以及一些区别,希望通过这些比较能够帮助小伙伴们加深对脏读、不可重复读、幻读的理解。 二、脏读 脏读: 指一个事务中访问到了另外一个事务未提交的数据(通俗地讲就是一...
  • 快速理解脏读、不可重复读和幻读

    千次阅读 多人点赞 2020-09-04 21:38:21
    具体的说,一个数据原本是干净的,但是事务B将它进行修改使得其不再干净,此时事务A读取到事务B修改后的数据,也就是脏数据,称为脏读,后来事务B由于良心发现又将数据回滚为最初的样子,而事务A不知道事务B进行了...
  • 数据库事务隔离级别(脏读、幻读、不可重复读)

    万次阅读 多人点赞 2018-08-12 18:12:47
    一、脏读、幻读和不可重复读 一、脏读、不可重复读、幻读 1、脏读脏读就是指当一个事务正在访问数据,并且对数据进行了修改,而这种修改还没有提交到数据库中,这时,另外一个事务也访问这个数据,然后使用了这...
  • 脏读可导致同一记录得到两个版本,或是完全地丢失一条记录。在同一事务中多次重新运行同一查询后,可能会出现幻读。最近MongoDB登上了Reddit的头条,因为MongoDB的核心开发者DavidGlasser痛苦地认识到MongoDB默认会...
  • 1、脏读、幻读、不可重复读示例;2、MySQL中的四种事务隔离级别
  • 事务中的脏写、脏读、不可重复读、幻读 首先来说一下事务中会发生的问题:脏写、脏读、不可重复读、幻读 假设id=5的记录最原始的username=“小王” 1.脏写 sessionA sessionB begin //开启事务 begin//...
  • 前两天整理之前的学习笔记时,发现对事务并发产生的问题——脏读、幻读、不可重复读和丢失更新这些概念有点模糊,于是又重新温习了一遍,现在把自己的一些理解归纳整理如下,方便大家学习。 锁就是防止其他事务...
  • 脏读:如果一个事务读到了另一个未提交事务修改过的数据,那就意味着发生了脏读(事务A读取事务B还未提交的数据,一旦事务B执行回滚操作,那么事务A读取到的数据就是不存在的) 不可重复读:一个事务对一个变量的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,192
精华内容 45,276
关键字:

脏读