Concurrent transactions

Question

Hi, please consider a plain old Java (not EJBs) application for a book store.
The application offer 3 operations:
1. Add new book (Store the book info in the DB).
2. Remove book (remove the book info from the DB).
3. Modify book (update the book info in the DB).
The system must support multiple users doing requests at the same time, thus the application must support concurrent transactions.
The ANSI/ISO SQL standard defines the four isolation levels: READ UNCOMMITTED, READ COMMITTED, REPEATABLE READS, SERIALIZABLE. Each level provides certain degree of isolation, the greatest isolation level is SERIALIZABLE but I've readed from several sources that it's not convenient to use this level because it causes a heavy impact in the performance and thus suggests to use READ COMMITTED.
As far I know, the first three isolation levels don't provide perfect isolation: they allow ugly problems to appear like dirty reads, unrepeatable reads and phantom reads.
What should I do to provide isolation to my system while using READ COMMITTED?
I think that lots of people have faced this problem over years, and the question is: Are there some "common" or "standard" techniques to solve this?
In other words, what is the correct approach to solve this?
Thank you very much for the help.

Answer 1

I have written two programs to test the situation.
The first program uses JDBC.
The second program uses hibernate.
Both programs show the same result: The final copies count is wrong. The "lost updates" problem is occurring in both.
Preconditions:
Create a database.
Create the table BOOK: create table BOOK (BOOK_ID INTEGER, TITLE VARCHAR(30), COPIES INTEGER, PRIMARY KEY(BOOK_ID))
Insert in the table the row with BOOK_ID = 1, Title = "The Java Patterns", COPIES = 7:
Below is the code for the JDBC test.
public class LostUpdatesTest3 {
     private static CyclicBarrier barrier = null;
     public static void main(String[] args) throws Exception {
          Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
          int numOfThreads = 5;
          Thread[] threads = new Thread[numOfThreads];          
          barrier = new CyclicBarrier(numOfThreads);
          for (int i = 0; i < numOfThreads; i++) {
               threads[i] = new MyTransaction();
               threads.setName("thread " + i);
               threads[i].start();
          for (Thread thread : threads) {
               thread.join();
     private static class MyTransaction extends Thread {
          public void run() {
               Connection con = null;
               try {
                    con = DriverManager.getConnection(
                              "jdbc:derby:d:/pruebas/jdbc1db;create=true", "root", "root");
                    con.setAutoCommit(false);
                    Statement statement = con.createStatement();
                    ResultSet resultSet = statement.executeQuery("SELECT * FROM BOOK");
                    resultSet.next();
          int id = resultSet.getInt("BOOK_ID");
          int copies = resultSet.getInt("COPIES");
                    barrier.await();
                    PreparedStatement preparedStatement = con.prepareStatement(
                    "UPDATE BOOK SET COPIES = ? WHERE BOOK_ID = ?");
                    preparedStatement.setInt(1, copies - 1);
                    preparedStatement.setInt(2, id);
                    preparedStatement.executeUpdate();
                    con.commit();
                    statement.close();
                    preparedStatement.close();
                    con.close();
               } catch (Exception e) {
                    e.printStackTrace();
This test creates 5 threads and starts them. Each thread runs a transaction to reduce 1 to the copies count.
At the end of the test, the book have COPIES = 6