parar - terminar un foreach java

Cómo interrumpir un bucle infinito

Question

Aunque sé que será un poco tonto preguntar, todavía quiero preguntar más sobre la perspectiva técnica del mismo.

Un simple ejemplo de un bucle infinito:

public class LoopInfinite {
public static void main(String[] args) {
for (;;) {
System.out.println("Stack Overflow");
}
}
}

¿Cómo puedo interrumpir (detener) este ciclo infinito desde fuera de esta clase (por ejemplo, con la ayuda de la herencia)?

Answer 1

Agregue una variable shouldBreak o algo que se puede establecer usando getter y setter.

public class LoopInfinite {
private boolean shouldBreak = false;
public boolean isShouldBreak() {
return shouldBreak;
}
public void setShouldBreak(boolean shouldBreak) {
this.shouldBreak = shouldBreak;
}
public static void main(String[] args) {
// Below code is just to simulate how it can be done from out side of
// the class
LoopInfinite infinite = new LoopInfinite();
infinite.setShouldBreak(true);
for (;;) {
System.out.println("");
if (infinite.shouldBreak)
break;
}
}

}

Answer 2

Aquí esta lo que hice:

while(Exit == false){
Scanner input = new Scanner(System.in);
String in = input.next();
switch(in){
case "FindH":
FindHyp hyp = new FindHyp();
float output = hyp.findhyp();
System.out.println(output);
case "Exit":
Exit = true;
break;
}
}

Answer 3

Creo que esto no es posible. Solo usando ruptura dentro del ciclo. Podrías usar

while(cond) {}

Y desde otro lugar lo hacen falso

Answer 4

Me siento sucio incluso escribiendo esto, pero ...

Desde un hilo diferente, puede llamar a System.setOut() con una implementación PrintStream , que arroja una RuntimeException cuando llama a println() .

Answer 5

No podrá interrumpir este bucle en particular sin detener por completo el proceso. En general, si está tratando de hacerlo desde una fuente externa (supongo que no tiene control sobre el código fuente, porque si lo hiciera podría establecer fácilmente una condición en el ciclo, como un booleano que podría establecer desde un subproceso externo), tendrá que detener el subproceso en ejecución, ya sea que lo haga a través del objeto Subproceso (tendrá que encontrar una referencia a él de alguna manera, por ejemplo al pasar por los subprocesos existentes ), o si lo detiene. como un proceso de sistema .

Otra opción sería anular el método con un bucle que no es un bucle infinito, pero desafortunadamente eso no se aplica a su ejemplo porque es un método estático.

Answer 6

No puedes detener esto desde fuera de esta clase. Si usa herencia, puede sobrescribir su bucle, pero sin abort-flag no podrá hacerlo.

Answer 7

Podemos lograrlo usando variables volatile , que cambiaremos el Thread externo y detendremos el ciclo.

 for(;!cancelled;) /*or while(!cancelled)*/{
System.out.println("");
}

Esta es una mejor forma de escribir Infinite Loop.

public class LoopInfinite{
private static volatile boolean cancelled=false;
public static void main(String[] args){
for(;!cancelled;) { //or while(!cancelled)
System.out.println("");
}
}
public void cancel(){
cancelled=true;
}
}

Answer 8

Pregunta muy abierta, pero detener dicho ciclo probablemente requiera que opere desde otro hilo. El otro subproceso necesitaría entonces establecer alguna variable que su bucle infinito pueda verificar regularmente, y si la variable tiene un cierto valor; salir del circuito.

Answer 9

Puede acceder al hilo que ejecuta el ciclo infinito desde un hilo diferente y llamar a la interrupción. Sin embargo, debes estar seguro de lo que estás haciendo y esperar que el hilo interrumpido se comporte correctamente cuando se interrumpa.

Aquí, he nombrado el hilo con el lazo ofensivo para una identificación más fácil. Tenga en cuenta que la siguiente solución es vulnerable a las condiciones de carrera.

 Thread loop = new Thread() {
public void run() {
Thread.currentThread().setName("loop");
while(true) {
System.out.print(".");
}
}
}.start();

Luego en alguna otra clase:

 ThreadGroup group = Thread.currentThread().getThreadGroup();
Thread[] threads = new Thread[group.activeCount()];
group.enumerate(threads);
for(Thread t : threads) {
if(t.getName().equals("loop")) {
/* Thread.stop() is a horrible thing to use.
Use Thread.interrupt() instead if you have
any control over the running thread */
t.stop();
}
}

Tenga en cuenta que en mi ejemplo supongo que los dos hilos están en el mismo ThreadGroup. No hay garantía de que este sea el caso, por lo que puede necesitar atravesar más grupos.

Si tiene algún control sobre esto, un patrón decente aquí sería tener while(!isInterrupted()) en su lugar en la declaración de bucle y usar t.interrupt() lugar de t.stop() .

Mi único consejo para usted, incluso después de publicar esto, es no hacer esto. Puedes hacerlo, pero realmente no deberías .

Answer 10

Puede interrumpir este hilo manteniendo su referencia estática de referencia heredada de este hilo [principal] preguntando a Thread.currentThread (), como este

public class LoopInfinite{
public static Thread main = null;
public static void main(String[] args){
main = Thread.currentThread();
for(;;)
System.out.println("");
}
}

Y para terminar puede llamar esto desde otro hilo

LoopInfinite.main.interrupt();

Pero solo funcionará si ambos hilos son parte del mismo grupo. De lo contrario, el hilo de llamada recibirá SecurityException

Answer 11

Si necesita un ciclo "infinito", seguramente necesita un hilo (de lo contrario, su aplicación quedará bloqueada hasta el final del ciclo).

class BigLoop extends Thread
{
private boolean _sexyAndAlive = true;
// make some constructor !
public void softTerminate()
{
_sexyAndAlive = false;
}
public void run()
{
try
{
while( _sexyAndAlive )
{
// Put your code here
}
}
catch( Some Exceptions ... )
{
// ...
}
// put some ending code here if needed
}
}
// in another file :
BigLoop worker = new BigLoop();
worker.start(); // starts the thread
// when you want to stop it softly
worker.softTerminate();

Entonces, este es un método simple para tener un bucle en ejecución de fondo.

Answer 12

Tu tipo de problema parece un problema de Threading. Pero aún así, ahora es una buena práctica incluir una bandera de detención incluso en hilos