How to set Spring boot with data JPA transactional in milliseconds

I am working on a high performance and highly response time critical application and need to timeout the spring data jpa transactions in milliseconds. It is not good for me to control it from a second. I have verified that it cannot be changed either through the @transactional annotation (org.springframework.transaction.annotation.Transactional) or through the TransactionManager interface. Both only allow exclusively to set the time in seconds. For me it is not a valid solution to change it at the level of queries with hint.

If it were not possible to do it in milliseconds, does anyone know why spring data jpa has this limitation?

Example code:

package net.codejava;
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
import org.springframework.transaction.annotation.Transactional;

@Service
public class ExpenseServiceImpl implements ExpenseService {

@Autowired
private ExpenseRepository repository;

    public void save(Expense expense) {
    	repository.save(expense);
    }
    
    public void execTransaction1() {
       repository.deleteAll();
       repository.save(new Expense(1L, "breakfast", 5));
       repository.save(new Expense(2L, "coffee", 2));
       repository.save(new Expense(3L, "New SSD drive", 200));
       repository.save(new Expense(4L, "Tution for baby", 350));
       repository.save(new Expense(5L, "Some apples", 5));
    }
    
     
    public void execTransaction2() {
       // repository.deleteAll();
       repository.save(new Expense(20L, "breakfast", 5));
    }
    
    
    @Transactional(timeout = 1000) // Only in seconds !!
    public void logicaCoordinacion() {
    	execTransaction1();
    	
    	execTransaction2();
    }

}

> I am working on a high performance and highly response time critical application and need to timeout the spring data jpa transactions in milliseconds.

The reason Spring does not allow @Transactional timeout with a millisecond granularity is because that would be unreliable. Spring can't guarantee that a garbage collector won't kicking in and that results in hundreds of milliseconds or even seconds on large heaps. There are also other issues that Spring has no control over: clock drift, OS thread scheduling, CPU clock frequency scaling, etc.

In practical terms a @Transactional timeout of 3s means that the timeout will happen somewhere around 3s mark. Since we are using seconds granularity, a few milliseconds later or earlier makes no practical difference.

The combination of Spring which is heavily based on reflection and JPA which is a heavyweight ORM layer doesn't feel like the right choice for a system that requires millisecond precision. You can try to set this timeout either directly in the JDBC driver on the database server side, perhaps it will be more reliable.