You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by ch...@apache.org on 2022/04/07 16:17:19 UTC

[flink] branch master updated: [FLINK-27125][tests] Fix ExecutorService leaks

This is an automated email from the ASF dual-hosted git repository.

chesnay pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/flink.git


The following commit(s) were added to refs/heads/master by this push:
     new 196d254fd72 [FLINK-27125][tests] Fix ExecutorService leaks
196d254fd72 is described below

commit 196d254fd72e95a3949a0763a7906ad8a861b2c9
Author: Chesnay Schepler <ch...@apache.org>
AuthorDate: Thu Apr 7 13:56:23 2022 +0200

    [FLINK-27125][tests] Fix ExecutorService leaks
---
 .../base/sink/writer/AsyncSinkWriterTest.java      | 44 ++++++++++++----------
 .../table/catalog/hive/HiveCatalogITCase.java      | 19 ++++++----
 .../hive/factories/HiveCatalogFactoryTest.java     |  9 ++++-
 .../connectors/kinesis/util/RecordEmitterTest.java | 14 ++++---
 .../core/security/FlinkSecurityManagerTest.java    |  8 +++-
 .../itcases/AbstractQueryableStateTestBase.java    |  9 ++++-
 .../io/network/buffer/LocalBufferPoolTest.java     | 19 +++++-----
 .../slotpool/PhysicalSlotProviderResource.java     | 13 ++++---
 .../FineGrainedSlotManagerTestBase.java            | 11 +++++-
 .../runtime/state/OperatorStateBackendTest.java    | 16 ++++----
 .../apache/flink/runtime/util/RunnablesTest.java   | 16 +++++---
 .../table/client/cli/CliTableauResultViewTest.java | 11 ++++--
 12 files changed, 116 insertions(+), 73 deletions(-)

diff --git a/flink-connectors/flink-connector-base/src/test/java/org/apache/flink/connector/base/sink/writer/AsyncSinkWriterTest.java b/flink-connectors/flink-connector-base/src/test/java/org/apache/flink/connector/base/sink/writer/AsyncSinkWriterTest.java
index 47c437e01e5..ce18e1111a7 100644
--- a/flink-connectors/flink-connector-base/src/test/java/org/apache/flink/connector/base/sink/writer/AsyncSinkWriterTest.java
+++ b/flink-connectors/flink-connector-base/src/test/java/org/apache/flink/connector/base/sink/writer/AsyncSinkWriterTest.java
@@ -884,26 +884,30 @@ public class AsyncSinkWriterTest {
         TestProcessingTimeService tpts = sinkInitContext.getTestProcessingTimeService();
         ExecutorService es = Executors.newFixedThreadPool(4);
 
-        tpts.setCurrentTime(0L);
-        sink.write("1");
-        sink.write("2");
-        es.submit(
-                () -> {
-                    try {
-                        sink.writeAsNonMailboxThread("3");
-                    } catch (IOException | InterruptedException e) {
-                        e.printStackTrace();
-                    }
-                });
-
-        delayedStartLatch.await();
-        sink.write("4");
-        tpts.setCurrentTime(100L);
-        blockedWriteLatch.countDown();
-        es.shutdown();
-        assertThat(es.awaitTermination(500, TimeUnit.MILLISECONDS))
-                .as("Executor Service stuck at termination, not terminated after 500ms!")
-                .isTrue();
+        try {
+            tpts.setCurrentTime(0L);
+            sink.write("1");
+            sink.write("2");
+            es.submit(
+                    () -> {
+                        try {
+                            sink.writeAsNonMailboxThread("3");
+                        } catch (IOException | InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    });
+
+            delayedStartLatch.await();
+            sink.write("4");
+            tpts.setCurrentTime(100L);
+            blockedWriteLatch.countDown();
+            es.shutdown();
+            assertThat(es.awaitTermination(500, TimeUnit.MILLISECONDS))
+                    .as("Executor Service stuck at termination, not terminated after 500ms!")
+                    .isTrue();
+        } finally {
+            es.shutdown();
+        }
     }
 
     /**
diff --git a/flink-connectors/flink-connector-hive/src/test/java/org/apache/flink/table/catalog/hive/HiveCatalogITCase.java b/flink-connectors/flink-connector-hive/src/test/java/org/apache/flink/table/catalog/hive/HiveCatalogITCase.java
index 77b289e166a..27304a82e53 100644
--- a/flink-connectors/flink-connector-hive/src/test/java/org/apache/flink/table/catalog/hive/HiveCatalogITCase.java
+++ b/flink-connectors/flink-connector-hive/src/test/java/org/apache/flink/table/catalog/hive/HiveCatalogITCase.java
@@ -417,14 +417,17 @@ public class HiveCatalogITCase {
     public void testConcurrentAccessHiveCatalog() throws Exception {
         int numThreads = 5;
         ExecutorService executorService = Executors.newFixedThreadPool(numThreads);
-        Callable<List<String>> listDBCallable = () -> hiveCatalog.listDatabases();
-        List<Future<List<String>>> listDBFutures = new ArrayList<>();
-        for (int i = 0; i < numThreads; i++) {
-            listDBFutures.add(executorService.submit(listDBCallable));
-        }
-        executorService.shutdown();
-        for (Future<List<String>> future : listDBFutures) {
-            future.get(5, TimeUnit.SECONDS);
+        try {
+            Callable<List<String>> listDBCallable = () -> hiveCatalog.listDatabases();
+            List<Future<List<String>>> listDBFutures = new ArrayList<>();
+            for (int i = 0; i < numThreads; i++) {
+                listDBFutures.add(executorService.submit(listDBCallable));
+            }
+            for (Future<List<String>> future : listDBFutures) {
+                future.get(5, TimeUnit.SECONDS);
+            }
+        } finally {
+            executorService.shutdown();
         }
     }
 
diff --git a/flink-connectors/flink-connector-hive/src/test/java/org/apache/flink/table/catalog/hive/factories/HiveCatalogFactoryTest.java b/flink-connectors/flink-connector-hive/src/test/java/org/apache/flink/table/catalog/hive/factories/HiveCatalogFactoryTest.java
index ac61c8ea9b7..c0fe191b35a 100644
--- a/flink-connectors/flink-connector-hive/src/test/java/org/apache/flink/table/catalog/hive/factories/HiveCatalogFactoryTest.java
+++ b/flink-connectors/flink-connector-hive/src/test/java/org/apache/flink/table/catalog/hive/factories/HiveCatalogFactoryTest.java
@@ -25,10 +25,12 @@ import org.apache.flink.table.catalog.CommonCatalogOptions;
 import org.apache.flink.table.catalog.hive.HiveCatalog;
 import org.apache.flink.table.catalog.hive.HiveTestUtils;
 import org.apache.flink.table.factories.FactoryUtil;
+import org.apache.flink.testutils.executor.TestExecutorResource;
 import org.apache.flink.util.TestLogger;
 
 import org.apache.hadoop.hive.conf.HiveConf;
 import org.junit.Assert;
+import org.junit.ClassRule;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -56,6 +58,10 @@ public class HiveCatalogFactoryTest extends TestLogger {
     private static final URL CONF_DIR =
             Thread.currentThread().getContextClassLoader().getResource("test-catalog-factory-conf");
 
+    @ClassRule
+    public static final TestExecutorResource<ExecutorService> EXECUTOR_RESOURCE =
+            new TestExecutorResource<>(() -> Executors.newFixedThreadPool(2));
+
     @Rule public final TemporaryFolder tempFolder = new TemporaryFolder();
 
     @Rule public ExpectedException expectedException = ExpectedException.none();
@@ -233,10 +239,9 @@ public class HiveCatalogFactoryTest extends TestLogger {
                                 null,
                                 Thread.currentThread().getContextClassLoader());
 
-        ExecutorService executorService = Executors.newFixedThreadPool(2);
+        ExecutorService executorService = EXECUTOR_RESOURCE.getExecutor();
         Future<Catalog> future1 = executorService.submit(callable1);
         Future<Catalog> future2 = executorService.submit(callable2);
-        executorService.shutdown();
 
         HiveCatalog catalog1 = (HiveCatalog) future1.get();
         HiveCatalog catalog2 = (HiveCatalog) future2.get();
diff --git a/flink-connectors/flink-connector-kinesis/src/test/java/org/apache/flink/streaming/connectors/kinesis/util/RecordEmitterTest.java b/flink-connectors/flink-connector-kinesis/src/test/java/org/apache/flink/streaming/connectors/kinesis/util/RecordEmitterTest.java
index 37e763924e3..20a5a1aaaac 100644
--- a/flink-connectors/flink-connector-kinesis/src/test/java/org/apache/flink/streaming/connectors/kinesis/util/RecordEmitterTest.java
+++ b/flink-connectors/flink-connector-kinesis/src/test/java/org/apache/flink/streaming/connectors/kinesis/util/RecordEmitterTest.java
@@ -19,9 +19,11 @@ package org.apache.flink.streaming.connectors.kinesis.util;
 
 import org.apache.flink.api.common.time.Deadline;
 import org.apache.flink.streaming.runtime.operators.windowing.TimestampedValue;
+import org.apache.flink.testutils.executor.TestExecutorResource;
 
 import org.hamcrest.Matchers;
 import org.junit.Assert;
+import org.junit.ClassRule;
 import org.junit.Test;
 
 import java.time.Duration;
@@ -34,6 +36,10 @@ import java.util.concurrent.Executors;
 /** Test for {@link RecordEmitter}. */
 public class RecordEmitterTest {
 
+    @ClassRule
+    public static final TestExecutorResource<ExecutorService> EXECUTOR_RESOURCE =
+            new TestExecutorResource<>(() -> Executors.newSingleThreadExecutor());
+
     private class TestRecordEmitter extends RecordEmitter<TimestampedValue> {
 
         private List<TimestampedValue> results = Collections.synchronizedList(new ArrayList<>());
@@ -67,15 +73,13 @@ public class RecordEmitterTest {
 
         queue1.put(two);
 
-        ExecutorService executor = Executors.newSingleThreadExecutor();
-        executor.submit(emitter);
+        EXECUTOR_RESOURCE.getExecutor().submit(emitter);
 
         Deadline dl = Deadline.fromNow(Duration.ofSeconds(10));
         while (emitter.results.size() != 4 && dl.hasTimeLeft()) {
             Thread.sleep(10);
         }
         emitter.stop();
-        executor.shutdownNow();
 
         Assert.assertThat(emitter.results, Matchers.contains(one, five, two, ten));
     }
@@ -109,8 +113,7 @@ public class RecordEmitterTest {
         emitter.setMaxLookaheadMillis(1);
         emitter.setCurrentWatermark(5);
 
-        ExecutorService executor = Executors.newSingleThreadExecutor();
-        executor.submit(emitter);
+        EXECUTOR_RESOURCE.getExecutor().submit(emitter);
         try {
             // emits one record past the limit
             Deadline dl = Deadline.fromNow(Duration.ofSeconds(10));
@@ -128,7 +131,6 @@ public class RecordEmitterTest {
             Assert.assertThat(emitter.results, Matchers.contains(one, two, three, ten, eleven));
         } finally {
             emitter.stop();
-            executor.shutdownNow();
         }
     }
 }
diff --git a/flink-core/src/test/java/org/apache/flink/core/security/FlinkSecurityManagerTest.java b/flink-core/src/test/java/org/apache/flink/core/security/FlinkSecurityManagerTest.java
index 0d082af4b4b..42a58ec2c4f 100644
--- a/flink-core/src/test/java/org/apache/flink/core/security/FlinkSecurityManagerTest.java
+++ b/flink-core/src/test/java/org/apache/flink/core/security/FlinkSecurityManagerTest.java
@@ -22,10 +22,12 @@ import org.apache.flink.configuration.ClusterOptions;
 import org.apache.flink.configuration.Configuration;
 import org.apache.flink.configuration.IllegalConfigurationException;
 import org.apache.flink.core.testutils.CheckedThread;
+import org.apache.flink.testutils.executor.TestExecutorResource;
 import org.apache.flink.util.TestLogger;
 
 import org.junit.After;
 import org.junit.Before;
+import org.junit.ClassRule;
 import org.junit.Test;
 
 import java.security.Permission;
@@ -45,6 +47,10 @@ import static org.junit.Assert.fail;
 /** Tests for {@code FlinkUserSecurityManager}. */
 public class FlinkSecurityManagerTest extends TestLogger {
 
+    @ClassRule
+    public static final TestExecutorResource<ExecutorService> EXECUTOR_RESOURCE =
+            new TestExecutorResource<>(() -> Executors.newSingleThreadExecutor());
+
     private static final int TEST_EXIT_CODE = 123;
     SecurityManager originalSecurityManager;
 
@@ -85,7 +91,7 @@ public class FlinkSecurityManagerTest extends TestLogger {
     public void testPerThreadThrowUserExit() throws Exception {
         FlinkSecurityManager flinkSecurityManager =
                 new FlinkSecurityManager(ClusterOptions.UserSystemExitMode.THROW, false);
-        ExecutorService executorService = Executors.newSingleThreadExecutor();
+        ExecutorService executorService = EXECUTOR_RESOURCE.getExecutor();
         // Async thread test before enabling monitoring ensures it does not throw while prestarting
         // worker thread, which is to be unmonitored and tested after enabling monitoring enabled.
         CompletableFuture<Void> future =
diff --git a/flink-queryable-state/flink-queryable-state-runtime/src/test/java/org/apache/flink/queryablestate/itcases/AbstractQueryableStateTestBase.java b/flink-queryable-state/flink-queryable-state-runtime/src/test/java/org/apache/flink/queryablestate/itcases/AbstractQueryableStateTestBase.java
index 39b5a367ff4..846a8645063 100644
--- a/flink-queryable-state/flink-queryable-state-runtime/src/test/java/org/apache/flink/queryablestate/itcases/AbstractQueryableStateTestBase.java
+++ b/flink-queryable-state/flink-queryable-state-runtime/src/test/java/org/apache/flink/queryablestate/itcases/AbstractQueryableStateTestBase.java
@@ -62,6 +62,7 @@ import org.apache.flink.streaming.api.operators.OneInputStreamOperator;
 import org.apache.flink.streaming.runtime.streamrecord.StreamRecord;
 import org.apache.flink.testutils.ClassLoaderUtils;
 import org.apache.flink.testutils.TestingUtils;
+import org.apache.flink.testutils.executor.TestExecutorResource;
 import org.apache.flink.util.Collector;
 import org.apache.flink.util.ExceptionUtils;
 import org.apache.flink.util.Preconditions;
@@ -112,8 +113,12 @@ public abstract class AbstractQueryableStateTestBase extends TestLogger {
     private static final Duration TEST_TIMEOUT = Duration.ofSeconds(200L);
     private static final long RETRY_TIMEOUT = 50L;
 
-    private final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);
-    private final ScheduledExecutor executor = new ScheduledExecutorServiceAdapter(executorService);
+    @ClassRule
+    public static final TestExecutorResource<ScheduledExecutorService> EXECUTOR_RESOURCE =
+            new TestExecutorResource<>(() -> Executors.newScheduledThreadPool(4));
+
+    private final ScheduledExecutor executor =
+            new ScheduledExecutorServiceAdapter(EXECUTOR_RESOURCE.getExecutor());
 
     /** State backend to use. */
     private StateBackend stateBackend;
diff --git a/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/buffer/LocalBufferPoolTest.java b/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/buffer/LocalBufferPoolTest.java
index 27ad6737608..56e1befddda 100644
--- a/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/buffer/LocalBufferPoolTest.java
+++ b/flink-runtime/src/test/java/org/apache/flink/runtime/io/network/buffer/LocalBufferPoolTest.java
@@ -20,11 +20,12 @@ package org.apache.flink.runtime.io.network.buffer;
 
 import org.apache.flink.core.memory.MemorySegment;
 import org.apache.flink.runtime.execution.CancelTaskException;
+import org.apache.flink.testutils.executor.TestExecutorResource;
 import org.apache.flink.util.TestLogger;
 
 import org.junit.After;
-import org.junit.AfterClass;
 import org.junit.Before;
+import org.junit.ClassRule;
 import org.junit.Test;
 import org.mockito.Mockito;
 
@@ -65,7 +66,9 @@ public class LocalBufferPoolTest extends TestLogger {
 
     private BufferPool localBufferPool;
 
-    private static final ExecutorService executor = Executors.newCachedThreadPool();
+    @ClassRule
+    public static final TestExecutorResource<ExecutorService> EXECUTOR_RESOURCE =
+            new TestExecutorResource<>(() -> Executors.newCachedThreadPool());
 
     @Before
     public void setupLocalBufferPool() throws Exception {
@@ -88,11 +91,6 @@ public class LocalBufferPoolTest extends TestLogger {
         networkBufferPool.destroy();
     }
 
-    @AfterClass
-    public static void shutdownExecutor() {
-        executor.shutdownNow();
-    }
-
     @Test
     public void testReserveSegments() throws Exception {
         NetworkBufferPool networkBufferPool =
@@ -367,8 +365,11 @@ public class LocalBufferPoolTest extends TestLogger {
         Future<Boolean>[] taskResults = new Future[numConcurrentTasks];
         for (int i = 0; i < numConcurrentTasks; i++) {
             taskResults[i] =
-                    executor.submit(
-                            new BufferRequesterTask(localBufferPool, numBuffersToRequestPerTask));
+                    EXECUTOR_RESOURCE
+                            .getExecutor()
+                            .submit(
+                                    new BufferRequesterTask(
+                                            localBufferPool, numBuffersToRequestPerTask));
         }
 
         for (int i = 0; i < numConcurrentTasks; i++) {
diff --git a/flink-runtime/src/test/java/org/apache/flink/runtime/jobmaster/slotpool/PhysicalSlotProviderResource.java b/flink-runtime/src/test/java/org/apache/flink/runtime/jobmaster/slotpool/PhysicalSlotProviderResource.java
index 6c5477b3cea..c21c29e3a11 100644
--- a/flink-runtime/src/test/java/org/apache/flink/runtime/jobmaster/slotpool/PhysicalSlotProviderResource.java
+++ b/flink-runtime/src/test/java/org/apache/flink/runtime/jobmaster/slotpool/PhysicalSlotProviderResource.java
@@ -40,9 +40,9 @@ import java.util.function.Function;
  */
 public class PhysicalSlotProviderResource extends ExternalResource {
 
-    private final ScheduledExecutorService singleThreadScheduledExecutorService;
+    private ScheduledExecutorService singleThreadScheduledExecutorService;
 
-    private final ComponentMainThreadExecutor mainThreadExecutor;
+    private ComponentMainThreadExecutor mainThreadExecutor;
 
     private final SlotSelectionStrategy slotSelectionStrategy;
 
@@ -51,15 +51,15 @@ public class PhysicalSlotProviderResource extends ExternalResource {
     private PhysicalSlotProvider physicalSlotProvider;
 
     public PhysicalSlotProviderResource(@Nonnull SlotSelectionStrategy slotSelectionStrategy) {
-        this.singleThreadScheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
-        this.mainThreadExecutor =
-                ComponentMainThreadExecutorServiceAdapter.forSingleThreadExecutor(
-                        singleThreadScheduledExecutorService);
         this.slotSelectionStrategy = slotSelectionStrategy;
     }
 
     @Override
     protected void before() throws Throwable {
+        this.singleThreadScheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
+        this.mainThreadExecutor =
+                ComponentMainThreadExecutorServiceAdapter.forSingleThreadExecutor(
+                        singleThreadScheduledExecutorService);
         slotPool = new DeclarativeSlotPoolBridgeBuilder().buildAndStart(mainThreadExecutor);
         physicalSlotProvider = new PhysicalSlotProviderImpl(slotSelectionStrategy, slotPool);
     }
@@ -67,6 +67,7 @@ public class PhysicalSlotProviderResource extends ExternalResource {
     @Override
     protected void after() {
         CompletableFuture.runAsync(() -> slotPool.close(), mainThreadExecutor).join();
+        singleThreadScheduledExecutorService.shutdown();
     }
 
     public CompletableFuture<PhysicalSlotRequest.Result> allocateSlot(PhysicalSlotRequest request) {
diff --git a/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/slotmanager/FineGrainedSlotManagerTestBase.java b/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/slotmanager/FineGrainedSlotManagerTestBase.java
index 56090dfb64e..b1b73a53d40 100644
--- a/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/slotmanager/FineGrainedSlotManagerTestBase.java
+++ b/flink-runtime/src/test/java/org/apache/flink/runtime/resourcemanager/slotmanager/FineGrainedSlotManagerTestBase.java
@@ -34,17 +34,21 @@ import org.apache.flink.runtime.slots.ResourceRequirements;
 import org.apache.flink.runtime.taskexecutor.SlotStatus;
 import org.apache.flink.runtime.taskexecutor.TestingTaskExecutorGatewayBuilder;
 import org.apache.flink.testutils.TestingUtils;
+import org.apache.flink.testutils.executor.TestExecutorResource;
 import org.apache.flink.util.FlinkException;
 import org.apache.flink.util.TestLogger;
 import org.apache.flink.util.concurrent.FutureUtils;
 import org.apache.flink.util.concurrent.ScheduledExecutor;
 import org.apache.flink.util.function.RunnableWithException;
 
+import org.junit.ClassRule;
+
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
@@ -53,7 +57,10 @@ import static org.junit.Assert.fail;
 
 /** Base class for the tests of {@link FineGrainedSlotManager}. */
 public abstract class FineGrainedSlotManagerTestBase extends TestLogger {
-    private static final Executor MAIN_THREAD_EXECUTOR = Executors.newSingleThreadExecutor();
+    @ClassRule
+    public static final TestExecutorResource<ExecutorService> EXECUTOR_RESOURCE =
+            new TestExecutorResource<>(() -> Executors.newSingleThreadExecutor());
+
     private static final long FUTURE_TIMEOUT_SECOND = 5;
     private static final long FUTURE_EXPECT_TIMEOUT_MS = 50;
     static final FlinkException TEST_EXCEPTION = new FlinkException("Test exception");
@@ -140,7 +147,7 @@ public abstract class FineGrainedSlotManagerTestBase extends TestLogger {
         private SlotManagerMetricGroup slotManagerMetricGroup =
                 UnregisteredMetricGroups.createUnregisteredSlotManagerMetricGroup();
         private final ScheduledExecutor scheduledExecutor = TestingUtils.defaultScheduledExecutor();
-        private final Executor mainThreadExecutor = MAIN_THREAD_EXECUTOR;
+        private final Executor mainThreadExecutor = EXECUTOR_RESOURCE.getExecutor();
         private FineGrainedSlotManager slotManager;
         private long requirementCheckDelay = 0;
 
diff --git a/flink-runtime/src/test/java/org/apache/flink/runtime/state/OperatorStateBackendTest.java b/flink-runtime/src/test/java/org/apache/flink/runtime/state/OperatorStateBackendTest.java
index c1e5e0d9d98..82637648090 100644
--- a/flink-runtime/src/test/java/org/apache/flink/runtime/state/OperatorStateBackendTest.java
+++ b/flink-runtime/src/test/java/org/apache/flink/runtime/state/OperatorStateBackendTest.java
@@ -40,10 +40,12 @@ import org.apache.flink.runtime.state.memory.MemoryStateBackend;
 import org.apache.flink.runtime.util.BlockerCheckpointStreamFactory;
 import org.apache.flink.runtime.util.BlockingCheckpointOutputStream;
 import org.apache.flink.runtime.util.TestingUserCodeClassLoader;
+import org.apache.flink.testutils.executor.TestExecutorResource;
 import org.apache.flink.util.Preconditions;
 import org.apache.flink.util.concurrent.FutureUtils;
 
 import org.junit.Assert;
+import org.junit.ClassRule;
 import org.junit.Test;
 
 import java.io.File;
@@ -73,6 +75,10 @@ import static org.mockito.Mockito.when;
 
 public class OperatorStateBackendTest {
 
+    @ClassRule
+    public static final TestExecutorResource<ExecutorService> EXECUTOR_RESOURCE =
+            new TestExecutorResource<>(() -> Executors.newFixedThreadPool(1));
+
     private final ClassLoader classLoader = getClass().getClassLoader();
     private final Collection<OperatorStateHandle> emptyStateHandles = Collections.emptyList();
 
@@ -759,7 +765,7 @@ public class OperatorStateBackendTest {
                 operatorStateBackend.snapshot(
                         1, 1, streamFactory, CheckpointOptions.forCheckpointWithDefaultLocation());
 
-        ExecutorService executorService = Executors.newFixedThreadPool(1);
+        ExecutorService executorService = EXECUTOR_RESOURCE.getExecutor();
 
         executorService.submit(runnableFuture);
 
@@ -913,9 +919,7 @@ public class OperatorStateBackendTest {
                 operatorStateBackend.snapshot(
                         1, 1, streamFactory, CheckpointOptions.forCheckpointWithDefaultLocation());
 
-        ExecutorService executorService = Executors.newFixedThreadPool(1);
-
-        executorService.submit(runnableFuture);
+        EXECUTOR_RESOURCE.getExecutor().submit(runnableFuture);
 
         // wait until the async checkpoint is in the write code, then continue
         waiterLatch.await();
@@ -963,9 +967,7 @@ public class OperatorStateBackendTest {
                 operatorStateBackend.snapshot(
                         1, 1, streamFactory, CheckpointOptions.forCheckpointWithDefaultLocation());
 
-        ExecutorService executorService = Executors.newFixedThreadPool(1);
-
-        executorService.submit(runnableFuture);
+        EXECUTOR_RESOURCE.getExecutor().submit(runnableFuture);
 
         // wait until the async checkpoint is in the stream's write code, then continue
         waiterLatch.await();
diff --git a/flink-runtime/src/test/java/org/apache/flink/runtime/util/RunnablesTest.java b/flink-runtime/src/test/java/org/apache/flink/runtime/util/RunnablesTest.java
index b527c93fc75..0c2dc69e89f 100644
--- a/flink-runtime/src/test/java/org/apache/flink/runtime/util/RunnablesTest.java
+++ b/flink-runtime/src/test/java/org/apache/flink/runtime/util/RunnablesTest.java
@@ -50,13 +50,17 @@ public class RunnablesTest extends TestLogger {
                         .setUncaughtExceptionHandler((t, e) -> handlerCalled.countDown())
                         .build();
         final ExecutorService executorService = Executors.newSingleThreadExecutor(threadFactory);
-        executorService.execute(
-                () -> {
-                    throw new RuntimeException("foo");
-                });
+        try {
+            executorService.execute(
+                    () -> {
+                        throw new RuntimeException("foo");
+                    });
 
-        // expect handler to be called
-        handlerCalled.await();
+            // expect handler to be called
+            handlerCalled.await();
+        } finally {
+            executorService.shutdown();
+        }
     }
 
     @Test
diff --git a/flink-table/flink-sql-client/src/test/java/org/apache/flink/table/client/cli/CliTableauResultViewTest.java b/flink-table/flink-sql-client/src/test/java/org/apache/flink/table/client/cli/CliTableauResultViewTest.java
index 9c472413ff3..4b666d7116e 100644
--- a/flink-table/flink-sql-client/src/test/java/org/apache/flink/table/client/cli/CliTableauResultViewTest.java
+++ b/flink-table/flink-sql-client/src/test/java/org/apache/flink/table/client/cli/CliTableauResultViewTest.java
@@ -33,11 +33,13 @@ import org.apache.flink.table.data.conversion.DataStructureConverter;
 import org.apache.flink.table.data.conversion.DataStructureConverters;
 import org.apache.flink.table.planner.functions.casting.RowDataToStringConverterImpl;
 import org.apache.flink.table.utils.print.RowDataToStringConverter;
+import org.apache.flink.testutils.executor.TestExecutorResource;
 import org.apache.flink.types.Row;
 import org.apache.flink.types.RowKind;
 
 import org.jline.terminal.Terminal;
 import org.junit.Before;
+import org.junit.ClassRule;
 import org.junit.Test;
 
 import java.io.ByteArrayOutputStream;
@@ -58,6 +60,9 @@ import static org.assertj.core.api.Assertions.fail;
 
 /** Tests for CliTableauResultView. */
 public class CliTableauResultViewTest {
+    @ClassRule
+    public static final TestExecutorResource<ExecutorService> EXECUTOR_RESOURCE =
+            new TestExecutorResource<>(() -> Executors.newSingleThreadExecutor());
 
     private ByteArrayOutputStream terminalOutput;
     private Terminal terminal;
@@ -235,8 +240,7 @@ public class CliTableauResultViewTest {
                 new CliTableauResultView(terminal, mockExecutor, "session", resultDescriptor);
 
         // submit result display in another thread
-        ExecutorService executorService = Executors.newSingleThreadExecutor();
-        Future<?> furture = executorService.submit(view::displayResults);
+        Future<?> furture = EXECUTOR_RESOURCE.getExecutor().submit(view::displayResults);
 
         // wait until we trying to get batch result
         CommonTestUtils.waitUntilCondition(
@@ -431,8 +435,7 @@ public class CliTableauResultViewTest {
                 new CliTableauResultView(terminal, mockExecutor, "session", resultDescriptor);
 
         // submit result display in another thread
-        ExecutorService executorService = Executors.newSingleThreadExecutor();
-        Future<?> furture = executorService.submit(view::displayResults);
+        Future<?> furture = EXECUTOR_RESOURCE.getExecutor().submit(view::displayResults);
 
         // wait until we processed first result
         CommonTestUtils.waitUntilCondition(