/* package whatever; // don't place package name! */
 
import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
 
/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
    private static final int GROUP_SIZE = 3;
    private static final Runnable FINISHER = () -> { System.out.println("finisher executing"); };
    private static final GroupMonitoringService MONITORING_SERVICE = new GroupMonitoringService(FINISHER, GROUP_SIZE);
 
    public static void main(String[] args) {
        final ScheduledExecutorService ses = Executors.newScheduledThreadPool(10);
        System.out.println("- [" + LocalTime.now() + "] run parent-task...");
 
        // create 3 tasks: each task needs 7 seconds.
        var tasks = createTasks();
        tasks.forEach(t -> ses.scheduleWithFixedDelay(t, 0, 2, TimeUnit.SECONDS));
    }
 
    private static List<Runnable> createTasks() {
        List<Runnable> result = new ArrayList<>();
        for (int i = 0; i < GROUP_SIZE; i++) {
            RandomWaitTask originalTask = new RandomWaitTask();
            CountingRunnable groupedTask = new CountingRunnable(originalTask, "Task " + i);
            Runnable notifyingRunnable = () -> {
                groupedTask.run();
                MONITORING_SERVICE.taskFinished(groupedTask.getGroup());
            };
            result.add(notifyingRunnable);
        }
        return result;
    }
}
 
class GroupMonitoringService {
    // key: group, value: tasks
    Map<String, AtomicInteger> finishedTasks = new HashMap<>();
    private final Runnable finisher;
    private final int groupSize;
 
    GroupMonitoringService(Runnable finisher, int groupSize) {
        this.finisher = finisher;
        this.groupSize = groupSize;
    }
 
    public synchronized void taskFinished(String group) {
        var finishedInGroup = finishedTasks.computeIfAbsent(group, k -> new AtomicInteger());
        if (finishedInGroup.incrementAndGet() >= groupSize) {
            // scheduling group complete
            System.out.printf("Group %s finished executing%n", group);
            finisher.run();
            finishedTasks.remove(group);
        }
    }
}
 
interface GroupedRunnable extends Runnable {
    String getGroup();
}
 
class CountingRunnable implements GroupedRunnable {
    private AtomicInteger counter = new AtomicInteger();
    private final Runnable delegate;
    private final String taskName;
 
    CountingRunnable(Runnable delegate, String taskName) {
        this.delegate = delegate;
        this.taskName = taskName;
    }
    public void run() {
        System.out.printf("[%s] - Running task %s in group %s%n", LocalTime.now(), taskName, getGroup());
        delegate.run();
        counter.incrementAndGet();
        System.out.printf("[%s] - Running task %s in group %s finished%n", LocalTime.now(), taskName, getGroup());
    }
 
    @Override
    public String getGroup() {
        return counter.toString();
    }
}
 
class RandomWaitTask implements Runnable {
    static final Random RANDOM = new Random();
    @Override
    public void run() {
        try {
            Thread.sleep(RANDOM.nextInt(10_000));
        } catch (InterruptedException e) {
        }
    }
}

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