Java Concurrency на практике: состояние гонки в BoundedExecutor?

Есть что-то странное в реализации BoundedExecutor в книге Java Concurrency in Practice.

Предполагается, что он будет регулировать отправку задач исполнителю, блокируя отправляющий поток, когда в исполнителе достаточно потоков, либо поставленных в очередь, либо запущенных в исполнителе.

Это реализация (после добавления отсутствующего повторного броска в предложении catch):

public class BoundedExecutor {
    private final Executor exec;
    private final Semaphore semaphore;

    public BoundedExecutor(Executor exec, int bound) {
        this.exec = exec;
        this.semaphore = new Semaphore(bound);
    }

    public void submitTask(final Runnable command) throws InterruptedException, RejectedExecutionException {
        semaphore.acquire();

        try {
            exec.execute(new Runnable() {
                @Override public void run() {
                    try {
                        command.run();
                    } finally {
                        semaphore.release();
                    }
                }
            });
        } catch (RejectedExecutionException e) {
            semaphore.release();
            throw e;
        }
    }

Когда я создаю экземпляр BoundedExecutor с Executors.newCachedThreadPool() и границей 4, я ожидаю, что количество потоков, созданных кэшированным пулом потоков, никогда не превысит 4. Однако на практике это так. Я получил эту небольшую тестовую программу для создания целых 11 потоков:

public static void main(String[] args) throws Exception {
    class CountingThreadFactory implements ThreadFactory {
        int count;

        @Override public Thread newThread(Runnable r) {
            ++count;
            return new Thread(r);
        }           
    }

    List<Integer> counts = new ArrayList<Integer>();

    for (int n = 0; n < 100; ++n) {
        CountingThreadFactory countingThreadFactory = new CountingThreadFactory();
        ExecutorService exec = Executors.newCachedThreadPool(countingThreadFactory);

        try {
            BoundedExecutor be = new BoundedExecutor(exec, 4);

            for (int i = 0; i < 20000; ++i) {
                be.submitTask(new Runnable() {
                    @Override public void run() {}
                });
            }
        } finally {
            exec.shutdown();
        }

        counts.add(countingThreadFactory.count);
    }

    System.out.println(Collections.max(counts));
}

Я думаю, что между выпуском семафора и завершением задачи есть крошечный промежуток времени, когда другой поток может получить разрешение и отправить задачу, в то время как освобождающий поток еще не завершился. Другими словами, у него есть состояние гонки.

Кто-нибудь может это подтвердить?