Multiple calls to Disposable.dispose() cause IllegalStateException – behavior uncertainty

Direct answer

The libgdx Disposable contract does not guarantee either behavior. The interface declares only void dispose(), and its Javadoc does not specify idempotency. Application code should treat disposal as a single-call responsibility: call dispose() exactly once per owned resource. Custom implementations should be defensive and ignore a second call rather than throw, because cleanup paths such as finally blocks can propagate an unchecked IllegalStateException and crash the application.

Likely explanation versus confirmed facts

Likely explanation: libgdx mirrors native OpenGL semantics, where the creator owns a resource and frees it once. Some core classes therefore track a disposed flag and throw on repeat calls, while others guard internally and return silently. This inconsistency is not an official specification; it is version- and class-dependent.

Confirmed facts: IllegalStateException is unchecked. ApplicationListener.dispose() is invoked once by the framework on shutdown. Manual disposal during screen transitions or asset reloads is where repeated calls surface. AssetManager reportedly disposes loaded assets once and treats later unload() calls as no-ops, but you should verify this in your dependency version.

Steps for this case

1. Inspect the source of each Disposable type you use for a disposed field or guard; do not assume idempotency.
2. In custom implementations, release native resources once, set a disposed flag, and return early on subsequent calls:

private boolean disposed;

public void dispose() {
    if (disposed) {
        return;
    }
    // release native handles here
    disposed = true;
}

1. If disposal can occur from multiple threads, guard the flag with synchronization or a thread-safe check.
2. Call dispose() once at the application level; do not rely on a second call being safe.
3. Add a unit test that invokes dispose() twice on every custom implementation and asserts no exception if idempotency is required.

Missing diagnostic detail

Are you calling dispose() manually outside ApplicationListener.dispose(), such as during screen or asset reloads? If only the framework lifecycle disposes resources, a single-call contract is sufficient; manual reload flows make idempotent guards necessary.

Assumption: this guidance applies to common libgdx usage, but behavior varies by class and version. Verify against the source of your exact libgdx release before relying on any class-specific behavior.