pregunta facil sobre función cronometro

[wintermute83]

Hola a todos. Creo que la siguiente pregunta va mas orientada a entender el concepto de OO, aqui la dejo:

Si yo creo una clase para medir el tiempo transcurrido y creo una instancia asi " Crono crono = new Crono();" el objeto vivirá hasta que la referencia "crono" desaparezca o apunte a null no es asi?
La cuestion es si tiene sentido querer crear un objeto que te de el tiempo transcurrido y eliminar el objeto hasta que quiera ese tiempo otra vez para lo cual creo una nueva instancia, o deberia simplemente crear un objeto que vive y devuelve tiempos para todos los demas objetos durante lo que dura el programa.

1er caso:

public class Crono {
    private long initTime;
    public void Crono(){
        initTime=System.currentTimeMillis();
    }
   
    public long close(){
        long finalTime=System.currentTimeMillis();
        long elapsedTime = finalTime - initTime;
       
        return elapsedTime;
    }
}

2º caso :

public class Crono {
    private long initTime;

    public long start(){
        initTime=System.currentTimeMillis();
    }

    public long stop(){
        long finalTime=System.currentTimeMillis();
        long elapsedTime = finalTime - initTime;
    }
}   
        return elapsedTime;
    }
}


espero haberme explicado mas o menos.
gracias y 1 saludo

[Vicente]

Esto, que es lo que quieres hacer?

[wintermute83]

mmm. supongo que me he precipitado con esto...

Lo que quiero es simplemente poder llamar a una función en un tiempo t para que al llamarla en un tiempo t+e me devuelva e. Un cronometro al que todos los objetos puedan llamar si necesitan saber el tiempo transcurrido entre 2 llamadas al cronometro.

Ahora mismo lo quiero para poder distinguir un poco mas entre los comandos del teclado, para cosas como si esta tecla esta pulsada mas de 1 segundo entonces pasa algo. Por ejemplo para poder realizar combos del estilo ( 2 seg atras + alante + x ) -> magia1.
Pero supongo que me será de utilidad para muchas mas cosas.

No tengo muy claro que enfoque deberia darle. Se me ocurren varias opciones.
1 crear un objeto cronometro al que todo objeto pueda pedir tiempos. El cronometro devolvería un indice a una lista en la que almacena el instante en el que es consultado, y despues devolveria el tiempo transcurrido cuando se le pasa el indice que se desea consultar.
"4 objetos usan cronometro, y 1 objeto cronometro sirve a los 4."

2 crear un objeto cronometro que mida el instante al ser creado y que viva hasta ser llamado para devolver el tiempo transcurrido . Aunque esto ultimo de eliminar un objeto no tengo muy claro como hacerlo, o si tiene sentido hacerlo.
"El objeto cronometro dura hasta que devuelve el tiempo transcurrido"

3 Que cada objeto que necesite conocer el tiempo transcurrido invoque 1 cronometro y que este cronometro devuelva tiempos durante la vida del objeto que lo invocó.
" 4 objetos -> 4 cronometros "

Entre el caso 1 y el 3 no se que sería lo conveniente o lo correcto.
Y el caso 2 en verdad no sabría como implementarlo.

Como lo hacéis vostros?
gracias

[Vicente]

El tercero, quien necesite un cronómetro que lo pida. De todas formas, huele a que estás usando Java, y seguramente Java ya tenga una clase que hace eso, mira la doc y te ahorras el programarla.

[wintermute83]

Gracias por la respuesta vicente, pero, podrias aclararme un poco porque es mejor?
Que conste que me suena mas a OO, un objeto por objeto. Pero este tipo de cuestiones me surgen cada poco, y un poco de fundamento siempre ayuda!

1 saludo

[Vicente]

La primera solución es un jaleo. Es decir, el cronómetro guarda una lista de objetos que le consultan? Tienes que guardar esa lista, administrarla,... Los objetos seguramente se morirán y tu seguirás guardándolos,... Todo inconvenientes.

La segunda no la entiendo :p

Y la tercera es la lógica: necesito algo, pues lo creo y lo uso. Igual que creas cualquier otra cosa: una lista, un string,...

[wintermute83]

Ok, ya empiezo a ver los inconvenientes...

la segunda idea en verdad no la veo clara yo tampoco asi que puede quedar en el olvido.

1 saludo y gracias!

[Hechelion]

Yo personalmente uso otro sistema, un único cronometro que lo único que hace es devolver el tiempo transcurrido desde que la aplicación está corriendo (En mi caso cuento los ciclos), cada objeto que necesite contar tiempo hace una consulta al cronometro y la almacena, cuando hace una segunda consulta la compara con el valor previo almacenado en el propio objeto y ya. Y el valor 0 lo uso como desactivado (ningún objeto puede pedir tiempo en el instante 0 de la aplicación).

Otra observación, si vas a contar segundos, entonces tu unidad de medida debe ser más precisa que un segundo, tu error de medición es la mitad de tu precisión.

Si cuentas segundos, tu error es +/- 0.5 segundos.
En dos mediciones, tu error será +/. 1 segundo.

Así que 2 segundos de una tecla se transforman en 2 +/- 1.

Otro ejemplo de la medición:
Tu objeto hace una llamada, el tiempo real transcurrido es de 10.499 segundos, pero el sistema  te devuelve 10
Tu objeto hace la segunda llamada en el momento 11.500, con lo cual el sistema almacena el valor 12

Realmente, sólo pasaron 11.500 - 10.499 = 1.001 segundos.
Pero el sistema contó 12-10 = 2 segundos.

Por eso, siempre que midas algo, debes tener en cuenta el error, en esté caso te recomiendo medir décimas de segundo si quieres tener tiempos relativamente precisos de 2 segundos.

[wintermute83]

Hechelion, estoy usando la clase System.currentTimeMillis de java. Devuelve un date tipo long y habia pensado dejarlo en milisegundos porque aunque no necesito nada mas que decimas de segundo no creo que ganase nada conviertiendo datos a otros de menor peso. O si?

[t-spy]

No, no ganas nada. Más bien perderías en velocidad de proceso al realizar operaciones de conversión que no necesitas.

Lo único que tienes que hacer es tener cuidado en las comparaciones. La diferencia entre los valores que registres estará en milisegundos, así que tendrás que comparar en esa magnitud.