L'uso di Runnable al di fuori del contesto del multithreading è valido?

Ispirato alla domanda SO , vorrei capire meglio il contratto definito da Runnable , insieme a quando è e non è accettabile utilizzare l'interfaccia Runnable . Sappiamo che il caso d'uso più comune di Runnable deve essere implementato da una classe che deve essere eseguita su un thread separato:

Runnable task = () -> {
    // Code to be executed on another thread
};
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(task);

Questo genera due domande:

1. Questo è l'unico modello accettabile per il suo utilizzo?
2. In caso contrario, quali sono altri pattern di utilizzo accettabili per Runnable che non ruotano attorno al multithreading?

Il caso d'uso nella domanda SO originale è di creare un modo generico per eseguire codice prima e dopo l'esecuzione di un metodo senza ripetizioni, come ad esempio:

public void example1() {
    before();
    method1();
    after();
}

public void example2() {
    before();
    method2();
    after();
}

La risposta di Eran propone di utilizzare Runnable per consentire l'incapsulamento della logica per ciascun metodo, insieme a un singolo metodo che accetta Runnable come argomento e richiama Runnable#run al momento opportuno:

public void call(Runnable method){
    before();
    method.run();
    after();
}

call( () -> { method1(); });
call( () -> { method2(); });

Tuttavia, l'utilizzo di Runnable in questo modo ha incontrato qualche disaccordo, affermando che questo non è un uso accettabile di Runnable . Questa è una preoccupazione valida o una questione di opinione stilistica?

Dalla mia ricerca, Javadoc per Runnable afferma il seguente contratto, che sembra essere ancora sostenuto con questo utilizzo di Runnable :

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread.

Inoltre, se l'utilizzo al di fuori del contesto del multithreading fosse scoraggiato o non consentito, mi aspetterei che:

1. Il Javadoc per menzionarlo da qualche parte, o
2. Runnable per essere in un pacchetto specifico della concorrenza, ad es. java.util.concurrent , tuttavia è disponibile in java.util .