tiempo - ejemplos de cronometro en java

¿Ejecuta código por x segundos en Java?

Question

Me gustaría escribir un ciclo java while que iterará durante 15 segundos. Una forma en que pensé hacer esto sería almacenar el tiempo actual del sistema + 15 segundos y luego compararlo con la hora actual en la firma del ciclo while.

¿Hay una mejor manera?

Answer 1

Aquí está mi sugerencia y está funcionando bien para mí :)

StoppingTime = 15 ;
int loop = 1;
long StartTime = System.currentTimeMillis() / 1000 ;
for (int i=0; i<loop; ++i) {
    // your code here

    loop++;
    if (((System.currentTimeMillis()/1000) - StartTime) > StoppingTime)
        loop=0;
}

Answer 2

Como ya se mencionó en otros carteles, si solo quieres que el hilo se detenga por algún tiempo, usa Thread.sleep() .

Si quieres que el hilo haga algo, pero quieres que pare después de un tiempo, usa algo como:

class Foo implements Runnable {
    private volatile boolean killed = false;

    public void run() {
        while (!killed) {
            try { doOnce(); } catch (InterruptedException ex) { killed = true; }
        }
    }

    public void kill() { killed = true; }
    private void doOnce() throws InterruptedException { /* .. */ }
}

y del hilo principal, hacer:

Foo foo = new Foo(); 
Thread thread = new Thread(foo);
thread.start();

/* when you want to stop it */
foo.kill();
thread.interrupt();

Answer 3

El diseño de esto depende de lo que quieras hacer durante 15 años. Los dos casos más plausibles son "haz esto cada X por 15 segundos" o "espera que X suceda o 15 segundos, lo que ocurra primero", lo que dará lugar a un código muy diferente.

A la espera

Thread.sleep(15000)

Esto no se repite, pero si no quieres hacer nada por 15s es mucho más eficiente (se desperdicia menos CPU sin hacer nada).

Repite un código para 15s

Si realmente quieres repetir 15s, tu solución está bien, siempre y cuando tu código no tarde demasiado. Algo como:

long t= System.currentTimeMillis();
long end = t+15000;
while(System.currentTimeMillis() < end) {
  // do something
  // pause to avoid churning
  Thread.sleep( xxx );
}

Espere 15 segundos o alguna otra condición

Si desea que su código se interrumpa después de exactamente 15 segundos, sea lo que sea que esté haciendo, necesitará una solución de subprocesos múltiples. Mira java.util.concurrent para muchos objetos útiles. La mayoría de los métodos que se bloquean (como wait ()) tienen un argumento de tiempo de espera excedido. Un semaphore puede hacer exactamente lo que necesita.

Answer 4

Nunca verifique la hora actual en un circuito cerrado.

De lo contrario, alguien con una computadora portátil puede obtener su regazo quemado por una CPU sobrecalentada. Escuché las historias de esto realmente sucediendo.

Answer 5

Para el enfoque java.util.concurrent , consulte el Capítulo 6 de Concurrencia de Java en la práctica (sección 6.3.7 Colocación de límites de tiempo en las tareas, página 131).

Ejemplo de código: Obtener un anuncio con un presupuesto de tiempo.

Answer 6

Puede que le interese programar un TimerTask que detenga otro hilo o cambie la condición de su ciclo.

Answer 7

Puede usar AOP y una anotación @Timeable desde jcabi-aspects (soy desarrollador):

@Timeable(limit = 1, unit = TimeUnit.SECONDS)
String load(String resource) {
  // do this check regularly:
  if (Thread.currentThread.isInterrupted()) {
    throw new IllegalStateException("time out");
  }
  // execution as normal
}

Cuando se alcanza el límite de tiempo, se activará interrupted() indicador de interrupted() thread) de la interrupted() thread) y será su trabajo manejar esta situación correctamente y detener la ejecución.

Answer 8

Su enfoque general parece estar bien, aunque es posible que desee ver si la hora actual es mayor que el punto que desea detener, de lo contrario, es posible que se ejecute durante un tiempo prolongado.

La alternativa es ejecutar un temporizador / hilo que establece un indicador después de que hayan transcurrido 15 segundos. Esta bandera debería estar marcada como volátil, de lo contrario, su ciclo podría no ver el cambio en el valor.

La elección, si le importa la eficiencia, ¿cuál es la más cara, para que el sistema tenga tiempo una vez por ciclo o para acceder a una variable volátil? No sé cuál es más eficiente; podría compararlo si es realmente importante.

Para un código simple y fácil de mantener, elegiría el enfoque de verificación del temporizador:

long endTime = System.currentTimeMillis() + 15000
while (System.currentTimeMillis() < endTime) {
  //loop
} 

Answer 9

Sugeriría que hagas esto con la clase de temporizador evitando Thread.sleep (xxx); método.

por ejemplo:

import java.util.Timer;
import java.util.TimerTask;

public class TimerExample {
    private int globalTimer = 0;
    private int limitTimer = 15;

    public static void main(String[] args) {
        new TimerExample();
    }

    public TimerExample() {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                globalTimer++;
                // DO YOUR CODE HERE
                System.out.println("running");
                if (globalTimer == limitTimer) {
                    timer.cancel();
                }
            }
        }, 0, 1000);
    }
}

Answer 10

Suponiendo que desea que el bucle haga algo sensato, puede encontrarlo más rápido para verificar una bandera volátil. Haga que otro hilo espere 15 segundos (o use un temporizador) y luego configúrelo.

Alternativamente, si sabe aproximadamente cuánto tiempo tomará el cuerpo del bucle, ejecútelo unos cientos de veces, por ejemplo, y verifique el tiempo en un bucle externo.

final long start = System.nanoTime();
do {
    for (int i=0; i<200, ++i) {
        ...
    }
} while (System.nanoTime()-start < 15L*1000L*1000L*1000L);

System.nanoTime no debe confundirse con los cambios del reloj del sistema. El uso de números literales largos es importante.

Answer 11

Una solución similar a @Tom Hawtin sin un tamaño de bucle arbitario.

final long end = System.nanoTime() + 15 * 1000 * 1000 * 1000L;
int loop = 1;
do {
    for (int i=0; i<loop; ++i) {
        ...
    }
    loop++;
} while (System.nanoTime() < end);

En este caso, el tamaño del bucle interno comenzará pequeño pero crecerá en tamaño si el bucle es particularmente rápido. Si es lo suficientemente lento, puede que solo se repita una vez.

Answer 12

prueba esto:

public class SleepMessages {
    public static void main(String args[]) throws InterruptedException {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };

        for (int i = 0; i < importantInfo.length; i++) {
            //Pause for 15 seconds
            Thread.sleep(15000);
            //Print a message
            System.out.println(importantInfo[i]);
        }
    }
}

más información: here