The Answer by Yevgeniy looks correct, regarding Java today. You want to have your cake and eat it too, in that you want a thread to sleep before repeating a task but you also want that thread to do other work. That is not possible today, but may be in the future.

Project Loom

In current Java, a Java thread is mapped directly to a host OS thread. In all common OSes such as macOS, BSD, Linux, Windows, and such, when code executing in a host thread blocks (stops to wait for sleep, or storage I/O, or network I/O, etc.) the thread too blocks. The blocked thread suspends, and the host OS generally runs another thread on that otherwise unused core. But the crucial point is that the suspended thread performs no further work until your blocking call to sleep returns.

This picture may change in the not-so-distant future. Project Loom seeks to add virtual threads to the concurrency facilities in Java.

In this new technology, many Java virtual threads are mapped to each host OS thread. Juggling the many Java virtual threads is managed by the JVM rather than by the OS. When the JVM detects a virtual thread’s executing code is blocking, that virtual thread is "parked", set aside by the JVM, with another virtual thread swapped out for execution on that "real" host OS thread. When the other thread returns from its blocking call, it can be reassigned to a "real" host OS thread for further execution. Under Project Loom, the host OS threads are kept busy, never idled while any pending virtual thread has work to do.

This swapping between virtual threads is highly efficient, so that thousands, even millions, of threads can be running at a time on conventional computer hardware.

Using virtual threads, your code will indeed work as you had hoped: A blocking call in Java will not block the host OS thread. But virtual threads are experimental, still in development, scheduled as a preview feature in Java 19. Early-access builds of Java 19 with Loom technology included are available now for you to try. But for production deployment today, you'll need to follow the advice in the Answer by Yevgeniy.

Take my coverage here with a grain of salt, as I am not an expert on concurrency. You can hear it from the actual experts, in the articles, interviews, and presentations by members of the Project Loom team including Ron Pressler and Alan Bateman.

EDIT: I just posted this answer and realized that you seem to be using that code to emulate real user interactions with some system. I would strongly recommend just using a load testing utility for that, rather than trying to come up with your own. However, in that case just using a CachedThreadPool might do the trick, although probably not a very robust or scalable solution.

Thread.sleep() behavior here is working as intended: it suspends the thread to let the CPU execute other threads. Note that in this state a thread can be interrupted for a number of reasons unrelated to your code, and in that case your Task returns false: I'm assuming you actually have some retry logic down the line.

So you want two mutually exclusive things: on the one hand, if the document isn't ready, the thread should be free to do something else, but should somehow return and check that document's status again in 10 seconds.

That means you have to choose:

• You definitely need that once-every-10-seconds check for each document - in that case, maybe use a cachedThreadPool and have it generate as many threads as necessary, just keep in mind that you'll carry the overhead for numerous threads doing virtually nothing.

• Or, you can first initiate that asynchronous document creation process and then only check for status in your callables, retrying as needed.

Something like:

public class Task implements Callable<Boolean> {
    private final ReportClient client;
    private final UUID uuid;
    // all args constructor omitted for brevity
    @Override
    public Boolean call() {
        GetStatusResponse status = client.getStatus(uuid);
        if (Status.PENDING.equals(status.status())) {
            final var document = client.getReport(uuid);
            return Boolean.TRUE;
        } else {
            return Boolean.FALSE; //retry next time
        }
    }
}

List<Callable<Boolean>> callableTasks = new ArrayList<>();
for (int i = 0; i < 100; i++) { 
    var uuid = client.createDocument(documentId); //not sure where documentId comes from here in your code
    callableTasks.add(new Task(client, uuid));
}

List<Future<Boolean>> results = SERVICE.invokeAll(callableTasks); 
// retry logic until all results come back as `true` here

This assumes that createDocument is relatively efficient, but that stage can be parallelized just as well, you just need to use a separate list of Runnable tasks and invoke them using the executor service. Note that we also assume that the document's status will indeed eventually change to something other than PENDING, and that might very well not be the case. You might want to have a timeout for retries.

In your case, it seems like you need to check if a certain condition is met every x seconds. In fact, from your code the document generation seems asynchronous and what the Task keeps doing after that is just is waiting for the document generation to happen.

You could launch every document generation from your Thread-Main and use a ScheduledThreadPoolExecutor to verify every x seconds whether the document generation has been completed. At that point, you retrieve the result and cancel the corresponding Task's scheduling.

Basically, one ConcurrentHashMap is shared among the thread-main and the Tasks you've scheduled (mapRes), while the other, mapTask, is just used locally within the thread-main to keep track of the ScheduledFuture returned by every Task.

public class Main {
    public static void main(String[] args) {
        ScheduledThreadPoolExecutor pool = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(8);

        //ConcurrentHashMap shared among the submitted tasks where each Task updates its corresponding outcome to true as soon as the document has been produced
        ConcurrentHashMap<Integer, Boolean> mapRes = new ConcurrentHashMap<>();
        for (int i = 0; i < 100; i++) {
            mapRes.put(i, false);
        }

        String uuid;
        ScheduledFuture<?> schedFut;

        //HashMap containing the ScheduledFuture returned by scheduling each Task to cancel their repetition as soon as the document has been produced
        Map<String, ScheduledFuture<?>> mapTask = new HashMap<>();
        for (int i = 0; i < 100; i++) {
            //Starting the document generation from the thread-main
            uuid = client.createDocument(documentId);

            //Scheduling each Task 10 seconds apart from one another and with an initial delay of i*10 to not start all of them at the same time
            schedFut = pool.scheduleWithFixedDelay(new Task(client, uuid, mapRes), i * 10, 10000, TimeUnit.MILLISECONDS);

            //Adding the ScheduledFuture to the map
            mapTask.put(uuid, schedFut);
        }

        //Keep checking the outcome of each task until all of them have been canceled due to completion
        while (!mapTasks.values().stream().allMatch(v -> v.isCancelled())) {
            for (Integer key : mapTasks.keySet()) {
                //Canceling the i-th task scheduling if:
                //  - Its result is positive (i.e. its verification is terminated)
                //  - The task hasn't been canceled already
                if (mapRes.get(key) && !mapTasks.get(key).isCancelled()) {
                    schedFut = mapTasks.get(key);
                    schedFut.cancel(true);
                }
            }

            //... eventually adding a sleep to check the completion every x seconds ...
        }

        pool.shutdown();
    }
}

class Task implements Runnable {

    private final ReportClient client;
    private final String uuid;

    private final ConcurrentHashMap mapRes;

    public Task(ReportClient client, String uuid, ConcurrentHashMap mapRes) {
        this.client = client;
        this.uuid = uuid;
        this.mapRes = mapRes;
    }

    @Override
    public void run() {
        //This is taken form your code and I'm assuming that if it's not pending then it's completed
        if (!Status.PENDING.equals(client.getStatus(uuid).status())) {
            mapRes.replace(uuid, true);
        }
    }
}

I've tested your case locally, by emulating a scenario where n Tasks wait for a folder with their same id to be created (or uuid in your case). I'll post it right here as a sample in case you'd like to try something simpler first.

public class Main {
    public static void main(String[] args) {
        ScheduledThreadPoolExecutor pool = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(2);

        ConcurrentHashMap<Integer, Boolean> mapRes = new ConcurrentHashMap<>();
        for (int i = 0; i < 16; i++) {
            mapRes.put(i, false);
        }

        ScheduledFuture<?> schedFut;
        Map<Integer, ScheduledFuture<?>> mapTasks = new HashMap<>();
        for (int i = 0; i < 16; i++) {
            schedFut = pool.scheduleWithFixedDelay(new MyTask(i, mapRes), i * 20, 3000, TimeUnit.MILLISECONDS);
            mapTasks.put(i, schedFut);
        }

        while (!mapTasks.values().stream().allMatch(v -> v.isCancelled())) {
            for (Integer key : mapTasks.keySet()) {
                if (mapRes.get(key) && !mapTasks.get(key).isCancelled()) {
                    schedFut = mapTasks.get(key);
                    schedFut.cancel(true);
                }
            }
        }

        pool.shutdown();
    }
}

class MyTask implements Runnable {
    private int num;
    private ConcurrentHashMap mapRes;

    public MyTask(int num, ConcurrentHashMap mapRes) {
        this.num = num;
        this.mapRes = mapRes;
    }

    @Override
    public void run() {
        System.out.println("Task " + num + " is checking whether the folder exists: " + Files.exists(Path.of("./" + num)));
        if (Files.exists(Path.of("./" + num))) {
            mapRes.replace(num, true);
        }
    }
}