chore(core): Make SchedulerExecutor thread pool size configurable

Signed-off-by: Alexander Dahmen <[email protected]>

Author: Fyusel

core/src/main/java/cloud/stackit/sdk/core/wait/AsyncActionHandler.java

@@ -31,11 +31,6 @@ public class AsyncActionHandler<T> {
 	private long timeoutMillis;
 	private int tempErrRetryLimit;
 
-	// The linter is complaining about this but since we are using Java 8 the
-	// possibilities are restricted.
-	// @SuppressWarnings("PMD.DoNotUseThreads")
-	// private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
-
 	public AsyncActionHandler(CheckFunction<AsyncActionResult<T>> checkFn) {
 		this.checkFn = checkFn;
 		this.sleepBeforeWaitMillis = 0;
@@ -140,7 +135,7 @@ public CompletableFuture<T> waitWithContextAsync() {
 		ScheduledFuture<?> scheduledFuture =
 				ScheduleExecutorSingleton.getInstance()
 						.getScheduler()
-						.scheduleAtFixedRate(
+						.scheduleWithFixedDelay(
 								checkTask,
 								sleepBeforeWaitMillis,
 								throttleMillis,
@@ -178,7 +173,7 @@ public T getResponse() {
 	/**
 	 * Helper function to check http status codes during deletion of a resource.
 	 *
-	 * @param e ApiException to check
+	 * @param apiException ApiException to check
 	 * @return true if resource is gone otherwise false
 	 */
 	public static boolean checkResourceGoneStatusCodes(ApiException apiException) {

core/src/main/java/cloud/stackit/sdk/core/wait/ScheduleExecutorSingleton.java

@@ -3,14 +3,32 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
-@SuppressWarnings("PMD.DoNotUseThreads")
+@SuppressWarnings({
+	"PMD.DoNotUseThreads",
+	"PMD.SingleMethodSingleton",
+	"PMD.NonThreadSafeSingleton"
+})
 public final class ScheduleExecutorSingleton {
-	// Pool size for the thread pool
-	private static final int POOL_SIZE = 1;
+	// Default pool size for the thread pool
+	private static final int DEFAULT_POOL_SIZE = 1;
+	private static ScheduleExecutorSingleton instance;
+	private static final Lock LOCK = new ReentrantLock();
 	private final ScheduledExecutorService scheduler;
 
+	/** Default constructor which takes the default pool size */
 	private ScheduleExecutorSingleton() {
+		this(DEFAULT_POOL_SIZE);
+	}
+
+	/**
+	 * Constructor to set a different pool size
+	 *
+	 * @param poolSize
+	 */
+	private ScheduleExecutorSingleton(int poolSize) {
 		// Use Daemon threads to prevent that the user need to call shutdown
 		// even if its program was already terminated
 		ThreadFactory daemonThreadFactory =
@@ -19,20 +37,28 @@ private ScheduleExecutorSingleton() {
 					thread.setDaemon(true);
 					return thread;
 				};
-		scheduler = Executors.newScheduledThreadPool(POOL_SIZE, daemonThreadFactory);
+		this.scheduler = Executors.newScheduledThreadPool(poolSize, daemonThreadFactory);
 	}
 
-	public ScheduledExecutorService getScheduler() {
-		return scheduler;
+	public static ScheduleExecutorSingleton getInstance() {
+		return getInstance(DEFAULT_POOL_SIZE);
 	}
 
-	// In order to make the Linter happy this is the only solution which is accepted.
-	// Lock/ReentrantLock, synchronized and volatile are in general not accepted.
-	private static final class SingletonHolder {
-		public static final ScheduleExecutorSingleton INSTANCE = new ScheduleExecutorSingleton();
+	public static ScheduleExecutorSingleton getInstance(int poolSize) {
+		if (instance == null) {
+			LOCK.lock();
+			try {
+				if (instance == null) {
+					instance = new ScheduleExecutorSingleton(poolSize);
+				}
+			} finally {
+				LOCK.unlock();
+			}
+		}
+		return instance;
 	}
 
-	public static ScheduleExecutorSingleton getInstance() {
-		return SingletonHolder.INSTANCE;
+	public ScheduledExecutorService getScheduler() {
+		return scheduler;
 	}
 }