[gradle][tooling extension][IDEA-382098] converted GradleExecutorServiceUtil from Java to Kotlin

GitOrigin-RevId: 125356ae639424df85072b6e8aee7cf803b9c1a0

plugins/gradle/tooling-extension-impl/src/com/intellij/gradle/toolingExtension/impl/util/GradleExecutorServiceUtil.kt

@@ -1,80 +1,68 @@
 // Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
-package com.intellij.gradle.toolingExtension.impl.util;
+package com.intellij.gradle.toolingExtension.impl.util
 
-import io.opentelemetry.context.Context;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import io.opentelemetry.context.Context
+import java.util.concurrent.*
+import java.util.function.Function
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.*;
-import java.util.function.Function;
+object GradleExecutorServiceUtil {
 
-public final class GradleExecutorServiceUtil {
-
-  public static <T> T withSingleThreadExecutor(@NotNull String name, @NotNull Function<ExecutorService, T> action) {
-    ExecutorService executorService = Executors.newSingleThreadExecutor(new SimpleThreadFactory(name));
+  @JvmStatic
+  fun <T> withSingleThreadExecutor(name: String, action: Function<ExecutorService, T>): T {
+    val executorService = Executors.newSingleThreadExecutor {
+      Thread(it, name)
+    }
     try {
-      return action.apply(executorService);
+      return action.apply(executorService)
     }
     finally {
-      executorService.shutdown();
+      executorService.shutdown()
       try {
-        executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
+        executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS)
       }
-      catch (InterruptedException e) {
-        Thread.currentThread().interrupt();
+      catch (e: InterruptedException) {
+        Thread.currentThread().interrupt()
       }
     }
   }
 
-  public static <T> void submitTask(
-    @NotNull ExecutorService executor,
-    @NotNull BlockingQueue<Future<T>> queue,
-    @NotNull Callable<T> task
+  @JvmStatic
+  fun <T> submitTask(
+    executor: ExecutorService,
+    queue: BlockingQueue<Future<T>>,
+    task: Callable<T>,
   ) {
-    Future<T> taskResult = Context.current()
+    val taskResult = Context.current()
       .wrap(executor)
-      .submit(task);
-    queue.add(taskResult);
+      .submit(task)
+    queue.add(taskResult)
   }
 
-  public static <T> @NotNull List<T> pollAllPendingResults(@NotNull BlockingQueue<Future<T>> queue) {
-    List<T> results = new ArrayList<>();
-    T result = poolPendingResult(queue);
+  @JvmStatic
+  fun <T> pollAllPendingResults(queue: BlockingQueue<Future<T>>): MutableList<T> {
+    val results = ArrayList<T>()
+    var result = poolPendingResult(queue)
     while (result != null) {
-      results.add(result);
-      result = poolPendingResult(queue);
+      results.add(result)
+      result = poolPendingResult(queue)
     }
-    return results;
+    return results
   }
 
-  public static <T> @Nullable T poolPendingResult(@NotNull BlockingQueue<Future<T>> queue) {
+  @JvmStatic
+  fun <T> poolPendingResult(queue: BlockingQueue<Future<T>>): T? {
     try {
-      Future<T> future = queue.poll();
+      val future = queue.poll()
       if (future == null) {
-        return null;
+        return null
       }
-      return future.get();
+      return future.get()
     }
-    catch (InterruptedException | ExecutionException ignored) {
-      return null;
+    catch (ignored: InterruptedException) {
+      return null
     }
-  }
-
-  // Use this static class as a simple ThreadFactory to prevent a memory leak when passing an anonymous ThreadFactory object to
-  // Executors.newSingleThreadExecutor. Memory leak will occur on the Gradle Daemon otherwise.
-  private static final class SimpleThreadFactory implements ThreadFactory {
-
-    private final String myName;
-
-    private SimpleThreadFactory(@NotNull String name) {
-      myName = name;
-    }
-
-    @Override
-    public Thread newThread(@NotNull Runnable runnable) {
-      return new Thread(runnable, myName);
+    catch (ignored: ExecutionException) {
+      return null
     }
   }
 }