Propagation REQUIRES_NEW may cause connection pool deadlock

[wlizhi]

A method that opens a transaction calls another method that starts a new transaction，if all connections are exhausted before the last new transaction method is executed,then all threads in the process will block，this process will fail.

Pseudo code：

@Transactional
methodA(){
    // All the threads that started the transaction were executed here, but the connection was exhausted.
    // The latter method execution will get a new connection,but it will never get it.
    @Transactional(propagation=Propagation.REQUIRES_NEW)
    methodB(){
    }
}

[quaff]

What's the problem?

[wlizhi]

Propagation.REQUIRES_NEW May cause all connections to be occupied.if this happens, the entire process will be blocked and unable to provide services

[wlizhi]

When all connections in the connection pool are occupied by the transaction method that does not execute to the last newly started transaction, all threads cannot obtain new connections, and the whole process will be blocked.

[quaff]

Do you know REQUIRES_NEW will double connections?

[wlizhi]

REQUIRES_NEW is not_ New will occupy two connections, but this transaction propagation behavior will suspend the previous transaction and restart a transaction. When a new transaction is opened, a new connection must be obtained. The previously suspended transaction connection will not be released.

[quaff]

It's by design, If first connection released, the outer transaction cannot continue.

[wlizhi]

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
if (debugEnabled) {
logger.debug("Suspending current transaction, creating new transaction with name [" +
definition.getName() + "]");
}
SuspendedResourcesHolder suspendedResources = suspend(transaction);
try {
return startTransaction(definition, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error beginEx) {
resumeAfterBeginException(transaction, suspendedResources, beginEx);
throw beginEx;
}
}

[wlizhi]

The above is the source code. When a new transaction is opened, the previous transaction will be suspended, so that the peripheral methods will occupy multiple connections during the execution process. Suppose that there are 50 connections in the database connection pool. At this time, 50 threads are just executing to the peripheral methods. They are all preparing to open new transactions and obtain new connections, but they will never get them because the connections have been exhausted.

[wlizhi]

After this happens, all connections in the process may be blocked.When this happens, all threads that will start the transaction will be blocked.

[wlizhi]

My question is, this way is likely to cause the whole process to block, so what is the significance of it?

[quaff]

As I said, if connection is released, the outer transaction cannot be resumed.
https://github.com/spring-projects/spring-framework/blob/master/spring-tx/src/main/java/org/springframework/transaction/support/AbstractPlatformTransactionManager.java#L604-L647

[wlizhi]

I know that if the connection has been released, the external transaction cannot be resumed. But REQUIRES_NEW may cause the whole process to hang up. So what's the point of it?

[quaff]

I explained why REQUIRES_NEW will double connections, If your connection pool is exhausted, you should increase max pool size, or handle the concurrency, for example by using Bulkhead of resilience4j, it's not responsibility of spring transaction.
I didn't get your point, do you think there is a bug or improvement here? If you want ask question, please visit stackoverflow.

[wlizhi]

@service
public class PropagationExampleServiceImpl implements PropagationExampleService {
@Autowired
PropagationExampleService propagationExampleService;

@Transactional
@Override
public void methodA() throws InterruptedException {
	Thread.sleep(100);
            // Assuming that multiple threads are executed here, all connections in the connection pool are used to open 
           // transactions of peripheral methods. Then they will never be released.
	propagationExampleService.methodB();
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void methodB() throws InterruptedException {
	Thread.sleep(100);
}

}