Implement a multithreaded task executor with semaphores

Design and implement a thread-safe TaskExecutor that limits concurrent work using a semaphore-like mechanism.

You are given an interface similar to:

• initialize(int maxThreads): sets up the executor with a maximum number of “worker permits”.
• acquire(int permits): blocks until the requested number of permits is available, then reserves them.
• execute(Task task, int input): runs a task while respecting the permit limit.

A Task is an interface and multiple subclasses implement different behaviors, but all must use the same interface. Each task declares:

• how many threads/permits it requires (e.g., requiredPermits()), and
• whether execute(...) should block until the task finishes (blocking) or return immediately while the task continues in the background (fire-and-forget).

Example tasks:

• MultiplyTask(factor, xPermits): multiplies input by factor, requires xPermits, and is fire-and-forget (i.e., execute should not wait for completion).
• DivideTask(divisor, yPermits): divides input by divisor, requires yPermits, and is blocking (i.e., execute returns only after completion and returns the computed result).

Requirements:

1. Total permits in use across all running tasks must never exceed maxThreads.
2. Permits must be released reliably even if a task throws.
3. The design should be extensible/maintainable: adding a new Task type should not require changing TaskExecutor logic beyond using the common Task interface.
4. Avoid busy-waiting; use proper concurrency primitives.

Specify the key classes/interfaces and implement the core logic of initialize, acquire, and execute (language: Java or pseudocode acceptable).