Welcome!

Linux Containers Authors: Zakia Bouachraoui, Yeshim Deniz, Elizabeth White, Liz McMillan, Pat Romanski

Related Topics: Java IoT

Java IoT: Article

Transactions in a JPA World

Week 38 of our Performance Almanac

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

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

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

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

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

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.

Related reading:

  1. JPA Under The Hood – Understanding the Dynamics of Your JPA Framework I recently gave a talks on the behaviour of different...
  2. Understanding Caching in Hibernate – Part Two : The Query Cache In the last post I wrote on caching in Hibernate...
  3. Hands-On Guide: Verifying FIFA World Cup Web Site against Performance Best Practices Whether you call it Football, Futbol, Fussball, Futebol, Calcio or...
  4. Understanding Caching in Hibernate – Part Three : The Second Level Cache In the last posts I already covered the session cache...
  5. Understanding Caching in Hibernate – Part One : The Session Cache Hibernate offers caching functionality which is designed to reduces...

More Stories By Alois Reitbauer

Alois Reitbauer is Chief Technical Strategist at Dynatrace. He has spent most of his career building monitoring tools and fine-tuning application performance. A regular conference speaker, blogger, author, and sushi maniac, Alois currently shares his professional time between Linz, Boston, and San Francisco.

IoT & Smart Cities Stories
Whenever a new technology hits the high points of hype, everyone starts talking about it like it will solve all their business problems. Blockchain is one of those technologies. According to Gartner's latest report on the hype cycle of emerging technologies, blockchain has just passed the peak of their hype cycle curve. If you read the news articles about it, one would think it has taken over the technology world. No disruptive technology is without its challenges and potential impediments t...
Nicolas Fierro is CEO of MIMIR Blockchain Solutions. He is a programmer, technologist, and operations dev who has worked with Ethereum and blockchain since 2014. His knowledge in blockchain dates to when he performed dev ops services to the Ethereum Foundation as one the privileged few developers to work with the original core team in Switzerland.
Andrew Keys is Co-Founder of ConsenSys Enterprise. He comes to ConsenSys Enterprise with capital markets, technology and entrepreneurial experience. Previously, he worked for UBS investment bank in equities analysis. Later, he was responsible for the creation and distribution of life settlement products to hedge funds and investment banks. After, he co-founded a revenue cycle management company where he learned about Bitcoin and eventually Ethereal. Andrew's role at ConsenSys Enterprise is a mul...
René Bostic is the Technical VP of the IBM Cloud Unit in North America. Enjoying her career with IBM during the modern millennial technological era, she is an expert in cloud computing, DevOps and emerging cloud technologies such as Blockchain. Her strengths and core competencies include a proven record of accomplishments in consensus building at all levels to assess, plan, and implement enterprise and cloud computing solutions. René is a member of the Society of Women Engineers (SWE) and a m...
If a machine can invent, does this mean the end of the patent system as we know it? The patent system, both in the US and Europe, allows companies to protect their inventions and helps foster innovation. However, Artificial Intelligence (AI) could be set to disrupt the patent system as we know it. This talk will examine how AI may change the patent landscape in the years to come. Furthermore, ways in which companies can best protect their AI related inventions will be examined from both a US and...
In his general session at 19th Cloud Expo, Manish Dixit, VP of Product and Engineering at Dice, discussed how Dice leverages data insights and tools to help both tech professionals and recruiters better understand how skills relate to each other and which skills are in high demand using interactive visualizations and salary indicator tools to maximize earning potential. Manish Dixit is VP of Product and Engineering at Dice. As the leader of the Product, Engineering and Data Sciences team at D...
Bill Schmarzo, Tech Chair of "Big Data | Analytics" of upcoming CloudEXPO | DXWorldEXPO New York (November 12-13, 2018, New York City) today announced the outline and schedule of the track. "The track has been designed in experience/degree order," said Schmarzo. "So, that folks who attend the entire track can leave the conference with some of the skills necessary to get their work done when they get back to their offices. It actually ties back to some work that I'm doing at the University of San...
When talking IoT we often focus on the devices, the sensors, the hardware itself. The new smart appliances, the new smart or self-driving cars (which are amalgamations of many ‘things'). When we are looking at the world of IoT, we should take a step back, look at the big picture. What value are these devices providing. IoT is not about the devices, its about the data consumed and generated. The devices are tools, mechanisms, conduits. This paper discusses the considerations when dealing with the...
Bill Schmarzo, author of "Big Data: Understanding How Data Powers Big Business" and "Big Data MBA: Driving Business Strategies with Data Science," is responsible for setting the strategy and defining the Big Data service offerings and capabilities for EMC Global Services Big Data Practice. As the CTO for the Big Data Practice, he is responsible for working with organizations to help them identify where and how to start their big data journeys. He's written several white papers, is an avid blogge...
Dynatrace is an application performance management software company with products for the information technology departments and digital business owners of medium and large businesses. Building the Future of Monitoring with Artificial Intelligence. Today we can collect lots and lots of performance data. We build beautiful dashboards and even have fancy query languages to access and transform the data. Still performance data is a secret language only a couple of people understand. The more busine...