public class ThreadPoolImpl implements ThreadPool {
    private Logger logger = LoggerFactory.getLogger(ThreadPoolImpl.class);
    private final ConcurrentMap<String, CompletableFuture<Void>> taskMap = new ConcurrentHashMap<>();
    private volatile boolean isStopped = false;
    private final ThreadPoolExecutor poolExecutor;

    public ThreadPoolImpl(int threadCount) {
        poolExecutor = new ThreadPoolExecutor(threadCount, threadCount, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
    }

    @Override
    public void execute(MyTask myTask) {
        if (isStopped) {
            throw new IllegalStateException("Pool already terminated");
        }
        final String key = myTask.getKey();
        taskMap.compute(key, (k, queue) -> {
            logger.info("Key " + key + " compute started");
            CountDownLatch countDownLatch = new CountDownLatch(1);
            CompletableFuture<Void> future = (queue == null)
                    ? CompletableFuture.runAsync(() -> {
                myTask.run();
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    logger.error("Thread pool thread was interrupted", e);
                }
            }, poolExecutor)
                    : queue.whenCompleteAsync((r, e) -> {
                myTask.run();
                try {
                    countDownLatch.await();
                } catch (InterruptedException ex) {
                    logger.error("Thread pool thread was interrupted", ex);
                }
            }, poolExecutor);
            //to prevent OutOfMemoryError in case if we will have too much keys
            future.whenComplete((r, e) -> taskMap.remove(key, future));
            countDownLatch.countDown();        
            logger.info("Key " + key + " compute finished");

            return future;
        });
    }

        taskMap.compute(key, (k, queue) -> {
...
                    countDownLatch.await();
...

executorService.submit(() -> executeTask(task));

whenCompleteAsync() ?