Home > Articles > Programming > Windows Programming

  • Print
  • + Share This
This chapter is from the book

Transaction Isolation

With Windows 2000, all COM+ transactions used the serialization level for transaction isolation. With Windows XP and Windows Server 2003, you can choose between different isolation levels. The full ACID properties that describe a transaction can only be fulfilled with the serializable transaction isolation level, but sometimes this level is not needed. Using a less-strict transaction isolation level can increase the scalability of the application.

With large numbers of users accessing data, turning knobs on transaction isolation can bring you a lot more performance than you can get out of fine-tuning components. With a data-driven application database, locks can make you lose a lot of performance.

If you want to change transaction isolation levels, you have to be aware of what can happen so that you know when you can change the default values.

Potential Transaction Isolation Problems

Potential problems that can occur during transactions can be grouped into three categories: dirty reads, nonrepeatable reads, and phantoms:

  • Dirty reads—A dirty read means that you can read data that was changed inside a transaction from outside of the transaction. Suppose that transaction 1 changes some customer data, but this transaction fails, so with a rollback the data is unchanged. If at the same time inside transaction 2 the same customer record is read, the data that is read never really existed, so this is called a dirty read.

  • Nonrepeatable reads—If the same row is read multiple times, and you get different results with each read, this is called a nonrepeatable read. If you read data in transaction 1, and at the same time transaction 2 changes the data that you have read within transaction 1, and you read the data again within transaction 1, different data will be read inside the same transaction. This is a nonrepeatable read.

  • Phantoms—A phantom is a row that matches the search criteria, but is not seen in the query. If you do a query based on a condition in transaction 1, while during transaction 2 a new record is inserted that would fit to the query of transaction 1, this row is a phantom. If all rows that match the query in transaction 1 are changed (for example, the salary of all employees that have a salary lower than $1,000 is changed to $1,000), new records that are added with a lower salary level are not updated.

Transaction Isolation Levels

Depending on the serialization level used, one of these described problems can occur, or the isolation level guarantees that the problem cannot occur. With the isolation level, you can specify one of these values: read uncommitted, read committed, repeatable read, or serializable:

  • Read uncommitted—With this level, transactions are not isolated from each other. This is the most scalable way for transactions; but with it, all problems described earlier can occur.

  • Read committed—With a level of read committed, the transaction waits until all write-locked rows that are manipulated by the transaction are unlocked. It is therefore guaranteed that no read of dirty data can occur.

  • The transaction holds a read lock for all rows that are read-only, and a write lock for all records that are updated or deleted. The read locks are released with a move to the next record, whereas all write locks are held until the transaction is committed or aborted.

  • Repeatable read—Repeatable read is functionally similar to read committed. The only difference is that the read locks are held until the transaction is committed or aborted. This way, nonrepeatable reads cannot happen anymore.

  • Serializable—Similar to read committed and repeatable read, the transaction waits until all write-locked rows that are manipulated by the transaction are unlocked. Similar to repeatable reads, read locks are done for rows that are read-only, and write locks are done for rows that are updated or deleted. What is different with this level is how ranges of data are locked. If a SELECT * FROM Customers statement is executed, a table lock is done. This way no new records can be inserted. With the SQL statement SELECT * FROM Customers WHERE City = ‘Vienna’, all records with the City column set to Vienna are locked. This way, phantoms are not possible.

Table 7-5 summarizes potential problems that can occur depending on the isolation level.

Table 7-5 Isolation Level Behavior

Isolation Level

Dirty Reads

Nonrepeatable Reads


Read uncommitted




Read committed




Repeatable read








When to Use Which Isolation Level

Consistency and concurrency have conflicting goals. For consistent data, locking must be done when the data is accessed. For best consistency, the transaction isolation level serializable offers the best support. Locking the data also means that no other task may access the data simultaneously. To get better concurrency, you must select a lower isolation level.

Depending on the task to be done, you can select the isolation level accordingly. If only new records are to be inserted, you can set the isolation level to read uncommitted. If data is read once, or multiple times, and if consistency is not required (for example, you are generating a management report), you can set the isolation level to read committed.

Thinking about configuring the isolation level always requires thinking about the complete task that should be protected, what can happen during the time of the task, and how this can influence the task. With this information, you can select the required isolation level.

Specifying the Isolation Level

You can specify the transaction isolation level of a serviced component with the attribute [Transaction] by defining the named property Isolation and setting a value to one of the defined values in the enumeration TransactionIsolationLevel.

                  Isolation = TransactionIsolationLevel.Any)]
      public class CustomerData : ServicedComponent

The possible values and their meaning of the enumeration TransactionIsolationLevel are shown in Table 7-6.

Table 7-6 TransactionIsolationLevel Enumeration

TransactionIsolationLevel Value



If you set the isolation level to Any, the same isolation level as the calling component is used. If the object is the root object, the isolation level is Serializable.


With ReadUncommitted, only shared locks are used; exclusive locks are not honored. You should use this option only for read access to generate some results that don’t need to be actually up to the second.


With this option, shared locks are used while data is being read. After reading the data, the shared lock is released. Before the transaction is finished, the data can be changed.


If you set the option to RepeatableRead, locks are placed on all data that is used.


The level Serializable has the best isolation. With this option, updates or inserts that belong to the range of the data that is used are not possible.

If using transactions without components, you can specify the transaction isolation level with the property IsolationLevel of the class ServiceConfig.

  • + Share This
  • 🔖 Save To Your Account