[Java] Anzahl der Verbindungen, die zum Verschachteln von Transaktionen erforderlich sind

Ist die Anzahl der verschachtelten Transaktionen = die Anzahl der erforderlichen Verbindungen? ?? ??

Bei der Schätzung der Poolgröße des Verbindungspools für die Stapelverarbeitung mit mehreren Threads erfolgt die Verschachtelung von Transaktionen. ** Natürlich ist auch die Anzahl der verschachtelten Verbindungen erforderlich **, also "Anzahl der Threads" x "Anzahl der verschachtelten Transaktionen" Ich stelle die Poolgröße ein.

Später war ich vage besorgt um ** natürlich ** in mir selbst und sagte: "Ist das wirklich der Fall (brauche ich einen Nistteil?)" ** Also habe ich beschlossen, einen Beispielcode zu erstellen und ihn zu überprüfen.

Fazit

Plötzlich gibt es keinen Körper oder Deckel, Anzahl der verschachtelten Transaktionen = Anzahl der erforderlichen Verbindungen war.

Wenn Sie also nur das Ergebnis wissen möchten, können Sie Folgendes überspringen.

Überprüfungsumgebung

• Oracle JDK 8 u161
• spring-boot 1.4.3
• Tomcat JDBC Connection Pool 8.5.6

Beispielcode (Auszug)

application.properties

# ConnectionPool
spring.datasource.tomcat.maxActive=1
spring.datasource.tomcat.maxIdle=1
spring.datasource.tomcat.minIdle=0
spring.datasource.tomcat.initialSize=0

App.java

@SpringBootApplication
public class App {

    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(App.class, args);
        Main bean = context.getBean(Main.class);
        bean.doNestedTransaction();
    }

}

Main.java

@Component
public class Main {

    @Autowired
    private MainTarnsaction mainTransaction;

    public void doNestedTransaction() {
        mainTransaction.beginTransaction();
    }

}

MainTarnsaction.java

@Component
public class MainTarnsaction {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private NestedTransaction nestedTransaction;

    @Transactional
    public void beginTransaction() {
        jdbcTemplate.execute("update Hoge set val = 'aaa' where id = '1'");
        nestedTransaction.beginTransaction();
    }

}

NestedTransaction.java

@Component
public class NestedTarnsaction {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void beginTransaction() {
        jdbcTemplate.execute("update Hoge set val = 'bbb' where id = '2'");
    }

}

Ausführungsergebnis

(1) Wenn die Poolgröße auf "1" ("spring.datasource.tomcat.maxActive = 1") gesetzt und ausgeführt wird

org.springframework.transaction.CannnotCreateTransactionException: Could not open JDBC Connection for transaction; nested exception is org.apache.tomcat.jdbc.pool.PoolExhaustedException: [main] Timeout: Pool empty. Unable to fetch a connection in 30 seconds. none available[size:1; busy:1; idel:0; lastwait:30000].
...
at xxx.NestedTransaction$$EnhancerBySpringCGLib$$xxx.beginTransaction(<generated>)
...
at xxx.MainTransaction$$EnhancerBySpringCGLib$$xxx.beginTransaction(<generated>)
at xxx.Main.doNestedTransaction(Main.java:xx)
...

Wie oben erwähnt, konnte die Verbindung für die verschachtelte Transaktion nicht aus dem Pool zugewiesen werden, und es ist eine Ausnahme aufgetreten.

(2) Wenn die Poolgröße auf "2" ("spring.datasource.tomcat.maxActive = 2") eingestellt und ausgeführt wird

Es endete normal (wie erwartet).

abschließend

Dadurch fühlte ich mich erfrischt. Ich hoffe, es wird für diejenigen hilfreich sein, die auf die gleiche Frage gestoßen sind.