TransactionSystemException in Grails @Transactional: async cancellation

Answer

Grails does not automatically cancel asynchronous work when a @Transactional(timeout=…) limit is exceeded; the timeout only aborts the database transaction and throws a TransactionSystemException. Any CompletableFuture, Promise or GPars task started inside the controller continues to run.

Confirmed facts

• The Spring transaction synchronization is bound to the thread that started the transaction.
• When the timeout triggers, Spring marks the transaction for roll‑back and throws TransactionSystemException on that thread.
• Async tasks run on separate threads (or fork‑join pool) and do not inherit the transaction synchronization, so they are unaware of the timeout.

Likely explanation

Because the timeout is enforced by Spring’s transaction manager, not by the async framework, there is no built‑in hook that propagates the exception to the async work. You must explicitly link the two.

Steps to cancel async work on timeout

1. In your service method, wrap the database call in a CompletableFuture and apply @Transactional to the call:

   @Transactional(timeout = 2)
   public CompletableFuture<Result> doWork() {
       return CompletableFuture.supplyAsync(() -> {
           // slow DB query or update
           return repository.findSomething();
       });
   }
   

2. In the controller, obtain the future and attach a timeout that matches or is shorter than the transaction timeout:

   def resultFuture = service.doWork()
   resultFuture.orTimeout(1, TimeUnit.SECONDS) // will complete exceptionally with TimeoutException after 1s
           .whenComplete((res, ex) -> {
               if (ex != null) {
                   // propagate cancellation or log
                   response.status = 500
                   render ex.message
               } else {
                   render res as JSON
               }
           });
   

3. If you need to interrupt the async thread, keep a reference to the CompletableFuture and call future.cancel(true) in the timeout handler:

   resultFuture.orTimeout(1, TimeUnit.SECONDS)
           .whenComplete((res, ex) -> {
               if (ex instanceof TimeoutException) {
                   resultFuture.cancel(true); // attempts to interrupt the running task
                   render status: 408, text: "Request timed out"
               }
           });
   

What to verify

• Run a test where the DB operation sleeps longer than the timeout (e.g., Thread.sleep(3000)).
• Confirm that after the timeout the controller receives an exceptional completion and the thread dump shows no lingering thread from the async task (or that it has been interrupted).
• Check that the transaction is rolled back (no DB changes).

Note: If you are using Grails Promise or GPars instead of raw CompletableFuture, the same principle applies: catch TransactionSystemException in the service and call promise.cancel() or complete the promise exceptionally. Let me know which async abstraction you are using so I can tailor the code.