El problema

Estoy ejecutando múltiples invocaciones de algún método externo a través de unServicio de ejecutor. Me gustaría poder interrumpir estos métodos, pero desafortunadamente no verifican la bandera de interrupción por sí mismos. ¿Hay alguna forma en que pueda forzar una excepción a partir de estos métodos?

Soy consciente de que lanzar una excepción desde una ubicación arbitraria espotencialmente peligroso, en mi caso específico, estoy dispuesto a aprovechar esta oportunidad y preparado para enfrentar las consecuencias.

Detalles

Por "método externo" me refiero a algunos métodos que provienen de una biblioteca externa, y no puedo modificar su código (bueno, puedo hacerlo, pero eso lo convertirá en una pesadilla de mantenimiento cada vez que se lance una nueva versión).

Los métodos externos son computacionalmente caros, no están vinculados a IO, por lo que no responden a interrupciones regulares y no puedo cerrar un canal o un zócalo o algo por la fuerza. Como he mencionado antes, tampoco verifican la bandera de interrupción.

El código es conceptualmente algo así como:

// my code
public void myMethod() {
    Object o = externalMethod(x);
}

// External code
public class ExternalLibrary {
    public Object externalMethod(Object) {
        innerMethod1();
        innerMethod1();
        innerMethod1();
    }

    private void innerMethod1() {
        innerMethod2();
        // computationally intensive operations
    }

    private void innerMethod2() {
        // computationally intensive operations
    }
}

Lo que he probado

Thread.stop() teóricamente hará lo que quiera, pero no solo está en desuso, sino que también está disponible para subprocesos reales, mientras estoy trabajando con tareas de ejecución (que también podrían compartir subprocesos con tareas futuras, por ejemplo, cuando se trabaja en un grupo de subprocesos) . Sin embargo, si no se encuentra una solución mejor, convertiré mi código para usar subprocesos anticuados y utilizaré este método.

Otra opción que he probado es marcarmyMethod() y métodos similares con una anotación especial "interrumpible" y luego usar AspectJ (del cual soy un novato) para detectar todas las invocaciones de métodos allí, algo como:

@Before("call(* *.*(..)) && withincode(@Interruptable * *.*(..))")
public void checkInterrupt(JoinPoint thisJoinPoint) {
    if (Thread.interrupted()) throw new ForcefulInterruption();
}

Perowithincode no es recursivo a los métodos llamados por los métodos coincidentes, por lo que tendría que editar esta anotación en el código externo.

Finalmente, esto es similar auna pregunta mía anterior - aunque una diferencia notable es que ahora estoy tratando con una biblioteca externa.