Welcome!

Mobile IoT Authors: Liz McMillan, Zakia Bouachraoui, Elizabeth White, Yeshim Deniz, Dana Gardner

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
The deluge of IoT sensor data collected from connected devices and the powerful AI required to make that data actionable are giving rise to a hybrid ecosystem in which cloud, on-prem and edge processes become interweaved. Attendees will learn how emerging composable infrastructure solutions deliver the adaptive architecture needed to manage this new data reality. Machine learning algorithms can better anticipate data storms and automate resources to support surges, including fully scalable GPU-c...
Machine learning has taken residence at our cities' cores and now we can finally have "smart cities." Cities are a collection of buildings made to provide the structure and safety necessary for people to function, create and survive. Buildings are a pool of ever-changing performance data from large automated systems such as heating and cooling to the people that live and work within them. Through machine learning, buildings can optimize performance, reduce costs, and improve occupant comfort by ...
The explosion of new web/cloud/IoT-based applications and the data they generate are transforming our world right before our eyes. In this rush to adopt these new technologies, organizations are often ignoring fundamental questions concerning who owns the data and failing to ask for permission to conduct invasive surveillance of their customers. Organizations that are not transparent about how their systems gather data telemetry without offering shared data ownership risk product rejection, regu...
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...
Poor data quality and analytics drive down business value. In fact, Gartner estimated that the average financial impact of poor data quality on organizations is $9.7 million per year. But bad data is much more than a cost center. By eroding trust in information, analytics and the business decisions based on these, it is a serious impediment to digital transformation.
Digital Transformation: Preparing Cloud & IoT Security for the Age of Artificial Intelligence. As automation and artificial intelligence (AI) power solution development and delivery, many businesses need to build backend cloud capabilities. Well-poised organizations, marketing smart devices with AI and BlockChain capabilities prepare to refine compliance and regulatory capabilities in 2018. Volumes of health, financial, technical and privacy data, along with tightening compliance requirements by...
Predicting the future has never been more challenging - not because of the lack of data but because of the flood of ungoverned and risk laden information. Microsoft states that 2.5 exabytes of data are created every day. Expectations and reliance on data are being pushed to the limits, as demands around hybrid options continue to grow.
Digital Transformation and Disruption, Amazon Style - What You Can Learn. Chris Kocher is a co-founder of Grey Heron, a management and strategic marketing consulting firm. He has 25+ years in both strategic and hands-on operating experience helping executives and investors build revenues and shareholder value. He has consulted with over 130 companies on innovating with new business models, product strategies and monetization. Chris has held management positions at HP and Symantec in addition to ...
Enterprises have taken advantage of IoT to achieve important revenue and cost advantages. What is less apparent is how incumbent enterprises operating at scale have, following success with IoT, built analytic, operations management and software development capabilities - ranging from autonomous vehicles to manageable robotics installations. They have embraced these capabilities as if they were Silicon Valley startups.
As IoT continues to increase momentum, so does the associated risk. Secure Device Lifecycle Management (DLM) is ranked as one of the most important technology areas of IoT. Driving this trend is the realization that secure support for IoT devices provides companies the ability to deliver high-quality, reliable, secure offerings faster, create new revenue streams, and reduce support costs, all while building a competitive advantage in their markets. In this session, we will use customer use cases...