How to manage shutdown of ExecutorService when we allow to inject it?

Suppose I am writing a service, which needs some executor service/separate thread. I give ability to use factory method to not worry about executor service, but still want to allow passing existing executor service (dependency injection).

How can I manage for executorService.shutdown()?

Example code:

public class ThingsScheduler {

    private final ExecutorService executorService;

    public ThingsScheduler(ExecutorService executorService) {
        this.executorService = executorService;
    }

    public static ThingsScheduler createDefaultSingleThreaded() {
        return new ThingsScheduler(Executors.newSingleThreadExecutor());
    }

    public scheduleThing() {
        executorService.submit(new SomeTask());
    }

    // implement Closeable?
    // @PreDestory?
    // .shutdown() + JavaDoc?
}

There are several problems

• We should have ability to shutdown internally created executor, or in best case handle it automatically (Spring @PreDestory, or in worst case finalize())
• We shold rather not shutdown executor if it's externally managed (injected)

We could create some attribute stating if executor is created by our class or if it's injected, and then on finalize/@PreDestroy/shutdown hook we could shut down it, but it not feels elegant for me.

Maybe we should completely resign from factory method and always require injection pushing executor lifecycle management to the client?

After some more thinking I came up with some conclusions:

• do not think about shutting it down if it's injected - someone else created it, someone else will manage it's lifecycle
• an executor factory could be injected instead of Executor, then we create instance using factory and manage closing it by ourself as we manage the lifecycle (and in such case responses from other users applies)