System.currentTimeMillis () frente a la nueva fecha () frente a Calendar.getInstance (). GetTime ()

En Java, ¿cuáles son las implicaciones de rendimiento y recursos del uso

System.currentTimeMillis() 

vs.

 new Date() 

vs.

 Calendar.getInstance().getTime() 

Según tengo entendido, System.currentTimeMillis () es el más eficiente. Sin embargo, en la mayoría de las aplicaciones, ese valor largo tendría que convertirse en una Fecha u otro objeto similar para hacer algo significativo para los humanos.

System.currentTimeMillis() es, obviamente, el más eficiente, ya que ni siquiera crea un objeto, pero la new Date() es realmente una envoltura delgada de una longitud considerable, por lo que no queda muy atrás. Calendar , por otro lado, es relativamente lento y muy complejo, ya que tiene que lidiar con la considerable complejidad y todas las rarezas que son inherentes a las fechas y horas (años bisiestos, horario de verano, zonas horarias, etc.).

En general, es una buena idea tratar solo con marcas de tiempo largas u objetos Date en su aplicación, y solo usar Calendar cuando realmente necesite realizar cálculos de fecha / hora, o formatear fechas para mostrarlos al usuario. Si tiene que hacer mucho de esto, usar Joda Time es probablemente una buena idea, para una interfaz más limpia y un mejor rendimiento.

Mirando el JDK, el constructor más interno para Calendar.getInstance() tiene esto:

 public GregorianCalendar(TimeZone zone, Locale aLocale) { super(zone, aLocale); gdate = (BaseCalendar.Date) gcal.newCalendarDate(zone); setTimeInMillis(System.currentTimeMillis()); } 

entonces ya hace automáticamente lo que sugieres. El constructor por defecto de Date tiene esto:

 public Date() { this(System.currentTimeMillis()); } 

Por lo tanto, realmente no es necesario obtener el tiempo del sistema específicamente a menos que desee hacer algunos cálculos con él antes de crear su objeto Calendario / Fecha con él. También tengo que recomendar joda-time para usar como reemplazo de las clases de calendario / fecha propias de Java si su propósito es trabajar mucho con los cálculos de fechas.

Si está usando una fecha, le recomiendo encarecidamente que utilice jodatime, http://joda-time.sourceforge.net/ . Usar System.currentTimeMillis() para los campos que son fechas suena como una muy mala idea porque terminarás con un montón de código inútil.

Tanto la fecha como el calendario están muy trabajados, y Calendar definitivamente es el que tiene el peor desempeño.

Te aconsejo que uses System.currentTimeMillis() cuando en realidad estés operando en milisegundos, por ejemplo, como este

  long start = System.currentTimeMillis(); .... do something ... long elapsed = System.currentTimeMillis() -start; 

Prefiero usar el valor devuelto por System.currentTimeMillis() para todo tipo de cálculos y solo uso Calendar o Date si realmente necesito mostrar un valor que sea leído por humanos. Esto también evitará el 99% de tus errores de horario de verano. 🙂

En mi máquina intenté comprobarlo. Mi resultado:

 Calendar.getInstance (). GetTime () (* 1000000 veces) = 402ms
 nueva fecha (). getTime ();  (* 1000000 veces) = 18ms
 System.currentTimeMillis () (* 1000000 veces) = 16ms

No se olvide de GC (si usa Calendar.getInstance() o new Date() )

Dependiendo de su aplicación, puede considerar usar System.nanoTime() lugar.

Intenté esto:

  long now = System.currentTimeMillis(); for (int i = 0; i < 10000000; i++) { new Date().getTime(); } long result = System.currentTimeMillis() - now; System.out.println("Date(): " + result); now = System.currentTimeMillis(); for (int i = 0; i < 10000000; i++) { System.currentTimeMillis(); } result = System.currentTimeMillis() - now; System.out.println("currentTimeMillis(): " + result); 

Y el resultado fue:

Fecha (): 199

currentTimeMillis (): 3

System.currentTimeMillis() es obviamente el más rápido porque es solo una llamada a método y no se requiere un recolector de elementos no utilizados.