Groovy future.get() returns null

I am working on a Groovy project to merge Sheets, but faced an issue over my async utils. I narrowed it down to that.

Here is the AsyncUtils:

package com.signaturemd.sposZohoMergeScript.utils

import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.Future

public final class AsyncUtils {
	private static ExecutorService threadPool;
	
	public static <T> Future<T> StartAsyncTask(Closure<T> onTask) { 
		return this.GetThreadPool()
			.submit(onTask);
	}
	
	public static <T> T AwaitResult(Future<T> future) {  
		return future.get();
	}
	
	public static ExecutorService GetThreadPool() { 
		if (!this.threadPool)
			this.threadPool = Executors.newCachedThreadPool();
		
		return this.threadPool;
	}
}

To try to resolve it, I write JUnit test case simulating my use case in the real project codebase:

package com.signaturemd.sposZohoMergeScript.utils;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class AsyncUtilsTest {

	@Test
	void testAwaitResult() {
		final List promises = [
			{
				Thread.sleep(100);
				return "hello";
			},
			{
				Thread.sleep(50);
				return "world";
			},
		].collect { Closure onTask -> return AsyncUtils.StartAsyncTask(onTask) }
		
		promises.each { promise -> 
			final String result = AsyncUtils.AwaitResult(promise);
			
			assert result != null;
		}
	}

}

The assertion is failing, as result is somehow null after awaiting the result...

What is causing this to happen, and does this mean I should wait on all promises (Futures) to resolve before starting unit of work (in my case merging)?

DISCLAIMER: I'm on Java 17

groovy Closure implements both - Runnable and Callable.

def c={'world'}

println c.call()  // ==> prints world
println c.run()   // ==> prints null

when you are calling ExecutorService.submit(Closure) compiler chooses Runnable interface of the closure.

Casting Closure to Callable solves the issue

import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.Future
import java.util.concurrent.Callable

@groovy.transform.CompileStatic
public final class AsyncUtils {
    private static ExecutorService threadPool;
    
    public static <T> Future<T> StartAsyncTask(Closure<T> onTask) { 
        return this.GetThreadPool()
            .submit((Callable)onTask);  // <<== the only effective change
    }
    
    public static <T> T AwaitResult(Future<T> future) {  
        return future.get();
    }
    
    public static ExecutorService GetThreadPool() { 
        if (!this.threadPool)
            this.threadPool = Executors.newCachedThreadPool();
        
        return this.threadPool;
    }
}

def future = AsyncUtils.StartAsyncTask{
     Thread.sleep(1000)
     return "world"
}

assert AsyncUtils.AwaitResult(future)=='world'

Turns out that I didn't need to create new thread pool or the equivalent of JS's async/await keywords. Just treat these Futures as the thennables...

• I don't need thread pool explicitly
• I don't need the async/await equivalent. It wouldn't work efficiently anyways. We want the first thennable that resolves, not to resolve them all in the order they're supplied.

I just change my util class to :

public final class AsyncUtils {
	
	public static <T> Future<T> StartAsyncTask(Closure<T> onTask) { 
		return CompletableFuture.supplyAsync(onTask)
	}
}

and then my test case, understanding (and simulating) the problem a bit more, to:

@Test
	void testStartAsyncTask() { 
		final List<CompletableFuture> promises = [
           {
        	   Thread.sleep(100);
        	   return "hello";
           },
           {
        	   Thread.sleep(50);
        	   return "world";
           },
       ].collect { Closure onTask -> return AsyncUtils.StartAsyncTask(onTask) }

	   promises.eachWithIndex { promise, int idx -> 
		   promise.thenApplyAsync { String str ->
			   if (idx == 0) { 
				   assert str.equals('world')
				   return
			   }
			   assert str.equals('hello')
		   }
	   }
	}

and all is well!