This is an automated email from the ASF dual-hosted git repository.
jt2594838 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git
The following commit(s) were added to refs/heads/master by this push:
new 8b7cf270f7e Fix pooled session cleanup and close races (#19288)
8b7cf270f7e is described below
commit 8b7cf270f7e47eec568afe412a7c366a46903502
Author: Caideyipi <[email protected]>
AuthorDate: Mon Nov 16 15:29:41 2026 +0800
Fix pooled session cleanup and close races (#19288)
* Fix pooled session and result-set cleanup
* Serialize table session lifecycle operations
* Make close concurrency test deterministic
---
.../org/apache/iotdb/session/pool/SessionPool.java | 47 ++-
.../iotdb/session/pool/TableSessionWrapper.java | 57 +--
.../iotdb/session/pool/SessionPoolCloseTest.java | 381 +++++++++++++++++++++
3 files changed, 448 insertions(+), 37 deletions(-)
diff --git
a/iotdb-client/session/src/main/java/org/apache/iotdb/session/pool/SessionPool.java
b/iotdb-client/session/src/main/java/org/apache/iotdb/session/pool/SessionPool.java
index 9585d65c390..86d11063480 100644
---
a/iotdb-client/session/src/main/java/org/apache/iotdb/session/pool/SessionPool.java
+++
b/iotdb-client/session/src/main/java/org/apache/iotdb/session/pool/SessionPool.java
@@ -819,16 +819,20 @@ public class SessionPool implements ISessionPool {
@SuppressWarnings({"squid:S2446"})
protected void putBack(ISession session) {
- queue.push(session);
synchronized (this) {
- // we do not need to notifyAll as any waited thread can continue to work
after waked up.
- this.notify();
- // comment the following codes as putBack is too frequently called.
- // if (logger.isTraceEnabled()) {
- // logger.trace("put a session back and notify others...,
queue.size = {}",
- // queue.size());
- // }
+ if (!closed) {
+ queue.push(session);
+ // we do not need to notifyAll as any waited thread can continue to
work after waked up.
+ this.notify();
+ // comment the following codes as putBack is too frequently called.
+ // if (logger.isTraceEnabled()) {
+ // logger.trace("put a session back and notify others...,
queue.size = {}",
+ // queue.size());
+ // }
+ return;
+ }
}
+ closeSession(session);
}
private void occupy(ISession session) {
@@ -872,22 +876,41 @@ public class SessionPool implements ISessionPool {
@Override
public void closeResultSet(SessionDataSetWrapper wrapper) {
+ ISession session;
+ synchronized (wrapper) {
+ session = wrapper.getSession();
+ if (session == null) {
+ return;
+ }
+ // Detach before returning the session, so closing an old wrapper cannot
release a new query.
+ wrapper.setSession(null);
+ session = occupied.remove(session);
+ }
+ if (session == null) {
+ return;
+ }
boolean putback = true;
try {
wrapper.getSessionDataSet().closeOperationHandle();
} catch (IoTDBConnectionException | StatementExecutionException e) {
- tryConstructNewSession();
putback = false;
+ cleanSessionAndMayThrowConnectionException(session);
} finally {
- ISession session = occupied.remove(wrapper.getSession());
- if (putback && session != null) {
- putBack(wrapper.getSession());
+ if (putback) {
+ putBack(session);
}
}
}
@SuppressWarnings({"squid:S2446"})
private void tryConstructNewSession() {
+ synchronized (this) {
+ if (closed) {
+ size--;
+ this.notify();
+ return;
+ }
+ }
Session session = constructNewSession();
try {
session.open(
diff --git
a/iotdb-client/session/src/main/java/org/apache/iotdb/session/pool/TableSessionWrapper.java
b/iotdb-client/session/src/main/java/org/apache/iotdb/session/pool/TableSessionWrapper.java
index 4cf7ca980f3..38b927e3867 100644
---
a/iotdb-client/session/src/main/java/org/apache/iotdb/session/pool/TableSessionWrapper.java
+++
b/iotdb-client/session/src/main/java/org/apache/iotdb/session/pool/TableSessionWrapper.java
@@ -57,7 +57,8 @@ public class TableSessionWrapper implements ITableSession {
}
@Override
- public void insert(Tablet tablet) throws StatementExecutionException,
IoTDBConnectionException {
+ public synchronized void insert(Tablet tablet)
+ throws StatementExecutionException, IoTDBConnectionException {
try {
session.insertRelationalTablet(tablet);
} catch (IoTDBConnectionException e) {
@@ -69,7 +70,7 @@ public class TableSessionWrapper implements ITableSession {
}
@Override
- public SessionDataSet executeQueryStatement(String sql)
+ public synchronized SessionDataSet executeQueryStatement(String sql)
throws StatementExecutionException, IoTDBConnectionException {
try {
return session.executeQueryStatement(sql);
@@ -82,7 +83,7 @@ public class TableSessionWrapper implements ITableSession {
}
@Override
- public SessionDataSet executeQueryStatement(String sql, long timeoutInMs)
+ public synchronized SessionDataSet executeQueryStatement(String sql, long
timeoutInMs)
throws StatementExecutionException, IoTDBConnectionException {
try {
return session.executeQueryStatement(sql, timeoutInMs);
@@ -95,7 +96,7 @@ public class TableSessionWrapper implements ITableSession {
}
@Override
- public void executeNonQueryStatement(String sql)
+ public synchronized void executeNonQueryStatement(String sql)
throws IoTDBConnectionException, StatementExecutionException {
try {
session.executeNonQueryStatement(sql);
@@ -108,40 +109,46 @@ public class TableSessionWrapper implements ITableSession
{
}
@Override
- public void close() throws IoTDBConnectionException {
- if (!Objects.equals(session.getSqlDialect(), sessionPool.sqlDialect)) {
- try {
- session.executeNonQueryStatement("set sql_dialect=" +
sessionPool.sqlDialect);
- } catch (StatementExecutionException e) {
- LOGGER.warn(
- SessionMessages
-
.LOG_FAILED_CHANGE_BACK_SQL_DIALECT_EXECUTING_SET_SQL_DIALECT_ARG_947F35E7,
- sessionPool.sqlDialect,
- e);
- session.close();
- session = null;
- return;
- }
+ public synchronized void close() throws IoTDBConnectionException {
+ if (!closed.compareAndSet(false, true)) {
+ return;
}
- if (closed.compareAndSet(false, true)) {
- if (!Objects.equals(session.getDatabase(), sessionPool.database)
+ Session closingSession = session;
+ session = null;
+ try {
+ if (!Objects.equals(closingSession.getSqlDialect(),
sessionPool.sqlDialect)) {
+ try {
+ closingSession.executeNonQueryStatement("set sql_dialect=" +
sessionPool.sqlDialect);
+ } catch (StatementExecutionException e) {
+ LOGGER.warn(
+ SessionMessages
+
.LOG_FAILED_CHANGE_BACK_SQL_DIALECT_EXECUTING_SET_SQL_DIALECT_ARG_947F35E7,
+ sessionPool.sqlDialect,
+ e);
+
sessionPool.cleanSessionAndMayThrowConnectionException(closingSession);
+ return;
+ }
+ }
+
+ if (!Objects.equals(closingSession.getDatabase(), sessionPool.database)
&& sessionPool.database != null) {
try {
- session.executeNonQueryStatement("use " + sessionPool.database);
+ closingSession.executeNonQueryStatement("use " +
sessionPool.database);
} catch (StatementExecutionException e) {
LOGGER.warn(
SessionMessages.LOG_FAILED_CHANGE_BACK_DATABASE_EXECUTING_USE_ARG_274541CA,
sessionPool.database,
e);
- session.close();
- session = null;
+
sessionPool.cleanSessionAndMayThrowConnectionException(closingSession);
return;
}
}
- sessionPool.putBack(session);
- session = null;
+ sessionPool.putBack(closingSession);
+ } catch (IoTDBConnectionException e) {
+ sessionPool.cleanSessionAndMayThrowConnectionException(closingSession);
+ throw e;
}
}
}
diff --git
a/iotdb-client/session/src/test/java/org/apache/iotdb/session/pool/SessionPoolCloseTest.java
b/iotdb-client/session/src/test/java/org/apache/iotdb/session/pool/SessionPoolCloseTest.java
new file mode 100644
index 00000000000..8e7558dda4e
--- /dev/null
+++
b/iotdb-client/session/src/test/java/org/apache/iotdb/session/pool/SessionPoolCloseTest.java
@@ -0,0 +1,381 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.iotdb.session.pool;
+
+import org.apache.iotdb.isession.ITableSession;
+import org.apache.iotdb.isession.SessionDataSet;
+import org.apache.iotdb.isession.pool.SessionDataSetWrapper;
+import org.apache.iotdb.rpc.IoTDBConnectionException;
+import org.apache.iotdb.rpc.StatementExecutionException;
+import org.apache.iotdb.session.Session;
+
+import org.apache.tsfile.write.record.Tablet;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InOrder;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.RETURNS_SELF;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class SessionPoolCloseTest {
+
+ private SessionPool pool;
+ private Session session;
+ private Session replacement;
+ private Session.Builder builder;
+
+ @Before
+ public void setUp() {
+ session = mock(Session.class);
+ replacement = mock(Session.class);
+ builder = mock(Session.Builder.class, RETURNS_SELF);
+ when(builder.build()).thenReturn(session, replacement);
+ when(session.getSqlDialect()).thenReturn("table");
+ when(session.getDatabase()).thenReturn("db");
+ when(replacement.getSqlDialect()).thenReturn("table");
+ when(replacement.getDatabase()).thenReturn("db");
+ pool = spy(new
SessionPool.Builder().maxSize(1).enableAutoFetch(false).build());
+ pool.sqlDialect = "table";
+ pool.database = "db";
+ doReturn(builder).when(pool).createSessionBuilder();
+ }
+
+ @After
+ public void tearDown() {
+ pool.close();
+ }
+
+ @Test
+ public void testTableSessionCloseIsIdempotent() throws Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ borrowed.close();
+ borrowed.close();
+
+ assertEquals(1, pool.currentAvailableSize());
+ verify(pool, times(1)).putBack(session);
+ verify(session, never()).close();
+ }
+
+ @Test
+ public void testConcurrentCloseAndConnectionFailureReplaceSessionOnce()
throws Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ IoTDBConnectionException failure = new IoTDBConnectionException("statement
failed");
+ CountDownLatch operationStarted = new CountDownLatch(1);
+ CountDownLatch continueOperation = new CountDownLatch(1);
+ CountDownLatch closeStarted = new CountDownLatch(1);
+ AtomicReference<Thread> closeThread = new AtomicReference<>();
+ doAnswer(
+ invocation -> {
+ operationStarted.countDown();
+ continueOperation.await();
+ throw failure;
+ })
+ .when(session)
+ .executeNonQueryStatement("flush");
+
+ ExecutorService executor = Executors.newFixedThreadPool(2);
+ try {
+ Future<IoTDBConnectionException> operation =
+ executor.submit(
+ () -> {
+ try {
+ borrowed.executeNonQueryStatement("flush");
+ return null;
+ } catch (IoTDBConnectionException e) {
+ return e;
+ }
+ });
+ assertTrue(operationStarted.await(5, TimeUnit.SECONDS));
+ Future<?> closing =
+ executor.submit(
+ () -> {
+ closeThread.set(Thread.currentThread());
+ closeStarted.countDown();
+ borrowed.close();
+ return null;
+ });
+ assertTrue(closeStarted.await(5, TimeUnit.SECONDS));
+ long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
+ while (!closing.isDone()
+ && closeThread.get().getState() != Thread.State.BLOCKED
+ && System.nanoTime() < deadline) {
+ Thread.yield();
+ }
+ assertFalse("close should wait for the in-flight operation",
closing.isDone());
+ assertEquals(Thread.State.BLOCKED, closeThread.get().getState());
+ continueOperation.countDown();
+
+ assertSame(failure, operation.get(5, TimeUnit.SECONDS));
+ closing.get(5, TimeUnit.SECONDS);
+ assertReplacementAvailable();
+ } finally {
+ continueOperation.countDown();
+ executor.shutdownNow();
+ }
+ }
+
+ @Test
+ public void testTableSessionRestoresStateBeforeReturning() throws Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ when(session.getSqlDialect()).thenReturn("tree");
+ when(session.getDatabase()).thenReturn("other");
+
+ borrowed.close();
+ borrowed.close();
+
+ InOrder order = inOrder(session, pool);
+ order.verify(session).executeNonQueryStatement("set sql_dialect=table");
+ order.verify(session).executeNonQueryStatement("use db");
+ order.verify(pool).putBack(session);
+ assertEquals(1, pool.currentAvailableSize());
+ }
+
+ @Test
+ public void testCloseAfterInsertConnectionFailure() throws Exception {
+ IoTDBConnectionException failure = new IoTDBConnectionException("insert
failed");
+ doThrow(failure).when(session).insertRelationalTablet(any(Tablet.class));
+ assertCloseAfterConnectionFailure(failure, s ->
s.insert(mock(Tablet.class)));
+ }
+
+ @Test
+ public void testCloseAfterQueryConnectionFailure() throws Exception {
+ IoTDBConnectionException failure = new IoTDBConnectionException("query
failed");
+ doThrow(failure).when(session).executeQueryStatement("select * from t");
+ assertCloseAfterConnectionFailure(failure, s ->
s.executeQueryStatement("select * from t"));
+ }
+
+ @Test
+ public void testCloseAfterTimedQueryConnectionFailure() throws Exception {
+ IoTDBConnectionException failure = new IoTDBConnectionException("query
failed");
+ doThrow(failure).when(session).executeQueryStatement("select * from t",
1000);
+ assertCloseAfterConnectionFailure(
+ failure, s -> s.executeQueryStatement("select * from t", 1000));
+ }
+
+ @Test
+ public void testCloseAfterNonQueryConnectionFailure() throws Exception {
+ IoTDBConnectionException failure = new IoTDBConnectionException("statement
failed");
+ doThrow(failure).when(session).executeNonQueryStatement("flush");
+ assertCloseAfterConnectionFailure(failure, s ->
s.executeNonQueryStatement("flush"));
+ }
+
+ @Test
+ public void testDialectResetStatementFailureReplacesSession() throws
Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ when(session.getSqlDialect()).thenReturn("tree");
+ doThrow(new StatementExecutionException("reset failed"))
+ .when(session)
+ .executeNonQueryStatement("set sql_dialect=table");
+
+ borrowed.close();
+ borrowed.close();
+
+ assertReplacementAvailable();
+ }
+
+ @Test
+ public void testDatabaseResetStatementFailureReplacesSession() throws
Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ when(session.getDatabase()).thenReturn("other");
+ doThrow(new StatementExecutionException("reset failed"))
+ .when(session)
+ .executeNonQueryStatement("use db");
+
+ borrowed.close();
+ borrowed.close();
+
+ assertReplacementAvailable();
+ }
+
+ @Test
+ public void testDialectResetConnectionFailureReplacesSession() throws
Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ when(session.getSqlDialect()).thenReturn("tree");
+ IoTDBConnectionException failure = new IoTDBConnectionException("reset
failed");
+ doThrow(failure).when(session).executeNonQueryStatement("set
sql_dialect=table");
+
+ assertSame(failure, assertThrows(IoTDBConnectionException.class,
borrowed::close));
+ borrowed.close();
+
+ assertReplacementAvailable();
+ }
+
+ @Test
+ public void testDatabaseResetConnectionFailureReplacesSession() throws
Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ when(session.getDatabase()).thenReturn("other");
+ IoTDBConnectionException failure = new IoTDBConnectionException("reset
failed");
+ doThrow(failure).when(session).executeNonQueryStatement("use db");
+
+ assertSame(failure, assertThrows(IoTDBConnectionException.class,
borrowed::close));
+ borrowed.close();
+
+ assertReplacementAvailable();
+ }
+
+ @Test
+ public void testFailedPhysicalCloseStillReplacesSession() throws Exception {
+ doThrow(new IoTDBConnectionException("close
failed")).when(session).close();
+ IoTDBConnectionException failure = new IoTDBConnectionException("statement
failed");
+ doThrow(failure).when(session).executeNonQueryStatement("flush");
+
+ assertCloseAfterConnectionFailure(failure, s ->
s.executeNonQueryStatement("flush"));
+ }
+
+ @Test
+ public void testOldResultSetCannotReleaseReborrowedSession() throws
Exception {
+ SessionDataSet firstDataSet = mock(SessionDataSet.class);
+ SessionDataSet secondDataSet = mock(SessionDataSet.class);
+ when(session.executeQueryStatement("select * from
t")).thenReturn(firstDataSet, secondDataSet);
+
+ try (SessionDataSetWrapper first = pool.executeQueryStatement("select *
from t")) {
+ assertFalse(first.hasNext());
+ try (SessionDataSetWrapper second = pool.executeQueryStatement("select *
from t")) {
+ first.close();
+ assertEquals(1, pool.currentOccupiedSize());
+ assertEquals(0, pool.currentAvailableSize());
+ }
+ }
+
+ assertEquals(0, pool.currentOccupiedSize());
+ assertEquals(1, pool.currentAvailableSize());
+ verify(firstDataSet, times(1)).closeOperationHandle();
+ verify(secondDataSet, times(1)).closeOperationHandle();
+ }
+
+ @Test
+ public void testResultSetConnectionFailureReplacesSessionOnce() throws
Exception {
+ SessionDataSet dataSet = mock(SessionDataSet.class);
+ when(session.executeQueryStatement("select * from t")).thenReturn(dataSet);
+ doThrow(new IoTDBConnectionException("close
failed")).when(dataSet).closeOperationHandle();
+
+ try (SessionDataSetWrapper result = pool.executeQueryStatement("select *
from t")) {
+ result.close();
+ result.close();
+ }
+
+ verify(dataSet, times(1)).closeOperationHandle();
+ assertEquals(0, pool.currentOccupiedSize());
+ assertReplacementAvailable();
+ }
+
+ @Test
+ public void testResultSetStatementFailureReplacesSessionOnce() throws
Exception {
+ SessionDataSet dataSet = mock(SessionDataSet.class);
+ when(session.executeQueryStatement("select * from t")).thenReturn(dataSet);
+ doThrow(new StatementExecutionException("close
failed")).when(dataSet).closeOperationHandle();
+
+ try (SessionDataSetWrapper result = pool.executeQueryStatement("select *
from t")) {
+ result.close();
+ result.close();
+ }
+
+ verify(dataSet, times(1)).closeOperationHandle();
+ assertEquals(0, pool.currentOccupiedSize());
+ assertReplacementAvailable();
+ }
+
+ @Test
+ public void testReturningTableSessionAfterPoolCloseClosesConnection() throws
Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ pool.close();
+
+ borrowed.close();
+ borrowed.close();
+
+ assertEquals(0, pool.currentAvailableSize());
+ verify(session, times(1)).close();
+ }
+
+ @Test
+ public void testConnectionFailureAfterPoolCloseDoesNotCreateReplacement()
throws Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ IoTDBConnectionException failure = new IoTDBConnectionException("statement
failed");
+ doThrow(failure).when(session).executeNonQueryStatement("flush");
+ pool.close();
+
+ assertSame(
+ failure,
+ assertThrows(
+ IoTDBConnectionException.class, () ->
borrowed.executeNonQueryStatement("flush")));
+ borrowed.close();
+
+ assertEquals(0, pool.currentAvailableSize());
+ verify(builder, times(1)).build();
+ verify(session, times(1)).close();
+ }
+
+ private void assertCloseAfterConnectionFailure(
+ IoTDBConnectionException failure, TableOperation operation) throws
Exception {
+ ITableSession borrowed = pool.getPooledTableSession();
+ assertSame(
+ failure,
+ assertThrows(
+ IoTDBConnectionException.class,
+ () -> {
+ try (ITableSession resource = borrowed) {
+ operation.execute(resource);
+ }
+ }));
+ borrowed.close();
+
+ assertEquals(0, failure.getSuppressed().length);
+ assertReplacementAvailable();
+ }
+
+ private void assertReplacementAvailable() throws Exception {
+ verify(session, times(1)).close();
+ assertEquals(1, pool.currentAvailableSize());
+ verify(builder, times(2)).build();
+ try (ITableSession recovered = pool.getPooledTableSession()) {
+ recovered.executeNonQueryStatement("select 1");
+ verify(replacement).executeNonQueryStatement("select 1");
+ }
+ assertEquals(1, pool.currentAvailableSize());
+ }
+
+ @FunctionalInterface
+ private interface TableOperation {
+ void execute(ITableSession session) throws Exception;
+ }
+}