java.sql.Timestamp forma de almacenar nanosegundos

Question

java.sql.Timestamp constructor de ir como esto:

public Timestamp(long time) { 
    super((time/1000)*1000); 
    nanos = (int)((time%1000) * 1000000); 
    if (nanos < 0) { 
     nanos = 1000000000 + nanos;  
     super.setTime(((time/1000)-1)*1000); 
    } 
} 

Básicamente acepta el tiempo en milisegundos y luego extrae los últimos 3 dígitos y lo hace nanos. Entonces, para un valor de milisegundo de 1304135631 , obtengo Timestamp.getnanos() como . Este es un cálculo simple (agregando 6 ceros al final) ... no parece ser óptimo.

Una mejor manera podría haber sido el constructor Timestamp que acepta tiempo en nanosegundos y luego calcula el valor de nanosegundos a partir de eso.

Si ejecuta el siguiente programa, verá la diferencia entre nanosegundos reales y el que devuelve Timestamp forma de calcular nanosecodos.

long a = System.currentTimeMillis(); 
    for(;;){ 
     long b = System.currentTimeMillis(); 
     Timestamp tm = new Timestamp(System.currentTimeMillis()); 
     System.out.println(tm.getTime()); 
     System.out.println(tm.getNanos()); 
     System.out.println("This is actual nanos" + System.nanoTime()%1000000000); 
     System.out.println("--------------------------"); 
     if(b-a >= 1) 
      break; 
    } 

Así que toda la discusión acerca de marca de fecha que dice que almacena el tiempo hasta nanosegundos, no parece ser tan correcto .. ¿No?

Answer 1

El tiempo en millis no representa el tiempo en nanos. Más preciso, simplemente no puede ser. Se supone que debes usar Timestamp#setNanos() para establecer los nanos reales.

long timeInMillis = System.currentTimeMillis(); 
long timeInNanos = System.nanoTime(); 

Timestamp timestamp = new Timestamp(timeInMillis); 
timestamp.setNanos((int) (timeInNanos % 1000000000)); 

// ... 

Answer 2

Aunque es un antiguo puesto, me gustaría añadir que los documentos de marca de hora sí afirma que "tiene fracciones de segundo, permitiendo la especificación de fracciones de segundo con una precisión de nanaoseconds". La parte confusa es "mantener". Esto parece confuso al principio, pero si se entiende correctamente, en realidad no indica que contenga nanaoseconds valor. Dice que "contiene" valor fraccionario y le permite ser una "precisión" de nanosegundos. La precisión se debe entender en términos de representación del número total de dígitos. Entonces, esencialmente significa que la parte es en realidad fraccional (todavía milisegundos) pero se multiplica por 1000000 para representarla en nanosegundos.

La respuesta aceptada (por siempre útil BaluC) lo resume muy bien.

Answer 3

Me gusta la implementación de OpenJPA de TimestampHelper. Utiliza los inicializadores estáticos para realizar un seguimiento de los nanosegundos transcurridos entre las llamadas para crear una marca de tiempo.

Answer 4

Desde la introducción de java.time.*, existe un nuevo método de fábrica en java.sql.Timestamp: Timestamp.from(Instant.now()) hará el trabajo (con precisión de nanosegundos). También hay Timestamp.toInstant() para convertirlo al revés.