Transactions in a JPA World

Week 38 of our Performance Almanac

Sep. 20, 2010 01:52 PM

The use of transactions is a cornerstone when building database applications. However in our daily work, we often do not really care much about them. In many cases they are handled implicitly for us by the (J EE) container or application framework – such as Spring – we are using. We rely on these frameworks to do a lot of the heaving lifting around transactions. At a pure JPA level there is a lot of transaction-related logic going on under the hood. This article discusses transactions at the JPA and database (JDBC) layer and how they play together and affect the functionality and performance of our applications.

JDBC and the Database
Before we dive into the details let’s spend some time on the basics. What are transactions all about? Transactions ensure that our interactions with the database follow the so-called ACID principles. In short we want to ensure that nothing weird happens when we store something in the database and we see all our operations as a logical unit which we can modify isolated from what other users are doing.

The easiest way to achieve this isolation is to use the database – or the data we are working with – just for ourselves. So we are locking the database rows in which we are interested in order that no one else can modify them. This is referred to as pessimistic locking. It is called pessimistic locking because even the most optimistic performance engineer will worry about the performance if it is done the wrong way. The opposite approach would be optimistic locking – assuming that nobody will modify the data while we work on it and only ensuring that we can handle concurrent modifications properly.

Every modern database provides a means to define which level of isolation we require. In Java they are exposed via JDBC. The golden rule is the higher the isolation the more performance impact we get. Let’s look at the different isolation levels starting from the lowest to the highest:

Read Uncommitted is the best performing way of reading data. It means we have no isolation at all and are seeing the data that others are modifying right now even if they have not committed their transactions. It actually means we have no isolation from other users’ operations at all. This level should only be used if you are only reading data that is not modified as otherwise it may lead to major data inconsistencies
Read Committed allows us only to read data that has already been committed by other transactions. This is now safer as we only see data of successfully committed transactions. However if we access the same record we might get different results back if other transactions committed during the two reads. This effect is called a “non-repeatable read”. Read committed is the default transaction level in most databases.
Repeatable Read ensures that we always get the same result for every record. So if accessed once we will also see the same value even if other transactions modified the data. While the data for a row will not change, the results of a query might change. Just think of a query with a where clause which is now fulfilled by recently modified rows as well. This behavior is referred to as a “phantom read”.
Serializable Transactions additionally avoid the problem of phantom reads. At the same time it has the highest performance impact of all transaction levels. Additionally you might – depending on the database implementation – run into problems of transaction serialization failures when serialization is not possible.

In addition to locks, explicit lock statements can be used to ensure repeatable read and serializable behavior of a database. However locks force other transactions to wait until the lock is released which may have an even higher performance impact.

The whole transaction behavior is controlled via the JDBC layer of the application. We can use connection properties to specify the isolation level and also issue explicit locking statements if needed.

Two worlds coming together
So far we have only dealt with the database and JDBC layer of our application. Most of the time, however, we do not interact directly with them. JPA frameworks abstract all that JDBC complexity which is great and one of the benefits of these frameworks. While we do not need to understand all the details of our database layer, it is good to see how higher-level interactions change this behavior and how we can influence it.

In order to get a basic understanding how those layers work together let’s start with a simple code sample and look at the resulting execution trace for it. Here we simply read a user from the database

public void loadOneObject (){
    EntityManager em = factory.createEntityManager();
    EntityTransaction t = em.getTransaction();
    Query query = em.createQuery("select user from User user where user.id= :userID");
    query.setParameter("userID", 1L);
    List users = query.getResultList();
    for (User user : users){
      user.getLastName();
    }
    em.close ();
 }

And here is what happens at the JPA and JDBC layers. We see that the interaction with the database happens in the getResultList method. Here the connection is acquired the statement is executed against the database and the ResultSet is traversed. Then the connection is returned back into the connection pool

Details of a simple JPA read operation

As a quick note I will be using Hibernate and MySQL for these examples. We could however use a different implementation as well.

Transactions in JPA
First, we do not interact with the database directly but via the EntityManager instead. The scope of this interaction is defined by a Persistence Context. A persistence context can be either managed by the J EE container (JTA) or in a standalone Java application (Resource Local). A persistence context comprises all entities being loaded during the interaction with the Entity Manager instance. From the time it is created we have another level of state in addition to the database. This additional state in the Persistence Context is also often referred to as the session cache. The session cache ensures that we get a consistent view on the data in the database and additionally avoid unnecessary creation of objects. Additionally, JPA frameworks offer query and cross-session (second-level) caches as well.

Let’s have a look at the example below. Here we are loading the same entity twice using a query. We have to use a query here as using the load method would result in a cache hit in the persistence context. Queries, however, are not cached by default. If you want to know more read this article on the Hibernate Query Cache.

  public void doubleLoad (){
    EntityManager em = factory.createEntityManager();
    Query query = em.createQuery("select user from User user where user.id= :userID");
    query.setParameter("userID", 1L);
    User u = (User)query.getSingleResult();
    // second  query
    query = em.createQuery("select user from User user where user.id= :userID");
    query.setParameter("userID", 1L);
    u = (User)query.getSingleResult();
    em.close ();
  }

Below we see a transaction trace of the above code. For both queries a call was made to the database. This was our intended behavior; so it is fine. However we also can see – marked in blue- that after the second query only the ID is read and not the value of lastname field. So why does this happen? Here we see the cache at work. It checks whether it has already loaded the object and if so it does not rebuild it again from the ResultSet. Rebuilding objects can have a significant performance impact; especially if there are a lot of eager-loading relations associated to it

Loading the Same Entity Twice
While in our case this causes no problems it might be different when the object has been modified between the two queries as the persistence framework does not check for any changes. This creates an additional isolation on top of the database even making committed changes not visible for the application. If we, however, want to ensure that we work with the latest committed version we have to use the refresh method. Using refresh will force the entity to be rebuilt from the ResultSet.

Synchronization with the Database
The next important question is when data is synchronized with the database. Normally this happens when a transaction is committed or the data is explicitly flushed to the database. However there are situations when additional synchronization with the database is required. The main reason is to provide consistency in query results. Let’s look at the following code sample.

  public void loadandModify (){
    EntityManager em = factory.createEntityManager();
    EntityTransaction t = em.getTransaction();
    t.begin();
    Query query = em.createQuery("select user from User user where user.id= :userID");
    query.setParameter("userID", 1L);
    User user = (User)query.getSingleResult();
    user.setLastName("A different name");
    query = em.createQuery("select user from User user where user.lastName like 'test%'");
    query.getResultList();
    t.commit();
  }

Here we load an entity from the database, modify a field and then execute a range query for the lastName parameter. This now creates a difficult situation for the JPA provider. It needs to execute a query against the database. However, the state of the database is not the latest state of the application. The JPA framework therefore must flush the changed entities to the database first as shown below.

Query Leading to Update Statement

In case queries and data updates are mixed throughout the code this may have a serious performance impact. Most likely this behavior will not be noticed during development, but will eventually lead to problems in production. The use of tracing solutions like dynaTrace helps to discover this kind of problems already early in development

Are JPA transactions equal to Database Transactions?
This is an important question and the simple answer is that they are not. As we have already learned, our transactional context starts when an entity manager is created. We can load and modify data already before we even start a start a transaction. We only need a transaction to commit our changes. The weird code sample below modifies an entity before even beginning a transaction. While this code works, it is obvious that it is a bad idea to write code like this.

  public void strangeCommit (){
 
    EntityManager em = factory.createEntityManager();
    EntityTransaction t = em.getTransaction();
    Query query = em.createQuery("select user from User user where user.id= :userID");
    query.setParameter("userID", 1L);
    User user = (User) query.getSingleResult();
    user.setLastName("Another last name");
    t.begin();
    t.commit();
    em.close ();    
 
  }

So when does a transaction in the database sense start then? Before talking about transactions we have to think about connections first. Having a database transaction requires us to hold a connection as transactions are always tied to connections. JPA providers offer several choices when a database connection is acquired and how long it is kept. There are three main possibilities:

A connection is requested every time a request to the database is made and then released immediately.
A connection is requested for the first query of a transaction and then kept until the transaction is committed.
A connection is requested when the Entity Manager is created.

Whichever approach you are using should not matter too much as the default transaction level will be read committed. However as soon as force your JPA provider to flush to the database while a transaction is not yet committed – like described above – you also force the EntityManager to keep a transaction, and thus a connection, open.

Explicit Locking
Additionally there is the possibility to explicitly lock entities. JPA comes with a set of different locking operations for reading and writing as well as optimistic and pessimistic locking. The general advice is only to use pessimistic locking when it is really necessary, as it has a higher performance impact and might lead to deadlocks.

Optimistic locking is best achieved by defining a Version attribute in your entities. When entity changes are then synchronized with the database, SQL statements are generated that check whether the entity has been modified in the meantime leading to an OptimisticLockingException. The code below uses two EntityManagers which modify the same Entity.

  public void lockingEntities (){
 
    EntityManager em1 = factory.createEntityManager();
    EntityManager em2 = factory.createEntityManager(); 
 
    em1.getTransaction().begin();
    User user1 = em1.find(User.class, 1L);
    user1.setLastName(user1.getLastName() + "%%");
 
    em2.getTransaction().begin();
    User user2 = em2.find(User.class, 1L);
    user2.setLastName(user2.getLastName() + "!");
 
    em2.getTransaction().commit();
    em1.getTransaction().commit();
  }

As you can see in the trace below the second update fails as the SQL statement with the version property in the WHERE clause does not affect the expected number of rows.

Optimistic Locking Failure Due to Version Conflict

The alternative solution would be to use a pessimistic lock. The code below explicitly locks the Entity with a pessimistic write lock.

  public void pessimisticLockingEntities (){
 
    EntityManager em1 = factory.createEntityManager();
    em1.getTransaction().begin();
    User user1 = em1.find(User.class, 1L);
    em1.lock(user1, LockModeType.PESSIMISTIC_WRITE);
    user1.setLastName("Other last name");
    em1.getTransaction().commit();
  }

As shown below, this results in a “select for update” SQL statement on the database. As mentioned earlier, explicit locking like this may yield to sever performance impact as well as deadlocks.

Pessimistic Lock of Entity with Database Lock

Conclusion

Understanding the transactional behavior is a cornerstone of writing functionally-correct and high-performing database applications. Using a JPA framework can make transaction handling a lot easier. However there are some important details regarding object state and transaction management a developer has to be aware of in order to avoid unwanted behavior. If we require more direct control over transaction behavior, the JPA specification – and additionally vendor specific APIs – provide more fine-grained control.