que - Java 8 Instant.now() con resolución de nanosegundos?

system.nanotime to seconds

Question

El java.time.Instant de Java 8 se almacena en "resolución de nanosegundos", pero el uso de Instant.now () solo proporciona una resolución de milisegundos ...

Instant instant = Instant.now();
System.out.println(instant);
System.out.println(instant.getNano());

Resultado...

2013-12-19T18:22:39.639Z
639000000

¿Cómo puedo obtener un Instant cuyo valor es ''ahora'', pero con una resolución de nanosegundos?

Answer 1

Así que pasé un tiempo buscando en el Javadoc aquí:

http://download.java.net/jdk8/docs/api/java/time/Instant.html

Parece que deberías poder hacer lo siguiente:

Instant inst = Instant.now();
long time = inst.getEpochSecond();
time *= 1000000000l; //convert to nanoseconds
time += inst.getNano(); //the nanoseconds returned by inst.getNano() are the nanoseconds past the second so they need to be added to the epoch second

Dicho esto, los demás respondedores señalan que va a ser muy difícil obtener una nano-segunda hora precisa ya que las computadoras simplemente no tienen la capacidad de rastrear el tiempo para esa resolución

Answer 2

Puede considerarse afortunado si obtiene incluso una resolución de milisegundos.

Instant puede modelar el tiempo con una precisión de nanosegundos, pero el equipo de la vida real en su computadora que realiza un seguimiento del tiempo de reloj de pared generalmente tiene una resolución de aproximadamente 10 ms, y la precisión casi seguramente es bastante inferior (100 ms sería una suposición optimista).

Compare esto con System.nanoTime() , que da resolución en microsegundos, pero no da el tiempo de reloj de pared absoluto. Claramente, ya hay una compensación en el trabajo para darle ese tipo de resolución, aún tres órdenes de magnitud por debajo de los nanosegundos.

Answer 3

Si bien el reloj Java8 predeterminado no proporciona una resolución de nanosegundos, puede combinarlo con la capacidad de Java para medir las diferencias de tiempo con la resolución de nanosegundos, creando así un reloj real con capacidad de nanosegundos.

public class NanoClock extends Clock
{
private final Clock clock;
private final long initialNanos;
private final Instant initialInstant;
public NanoClock()
{
this(Clock.systemUTC());
}
public NanoClock(final Clock clock)
{
this.clock = clock;
initialInstant = clock.instant();
initialNanos = getSystemNanos();
}
@Override
public ZoneId getZone()
{
return clock.getZone();
}
@Override
public Instant instant()
{
return initialInstant.plusNanos(getSystemNanos() - initialNanos);
}
@Override
public Clock withZone(final ZoneId zone)
{
return new NanoClock(clock.withZone(zone));
}
private long getSystemNanos()
{
return System.nanoTime();
}
}

Su uso es sencillo: simplemente proporcione un parámetro adicional a Instant.now (), o llame a Clock.instant () directamente:

 final Clock clock = new NanoClock();
final Instant instant = Instant.now(clock);
System.out.println(instant);
System.out.println(instant.getNano());

Aunque esta solución podría funcionar incluso si vuelve a crear instancias de NanoClock cada vez, siempre es mejor quedarse con un reloj almacenado al inicio de su código, y luego usarlo donde sea necesario.

Answer 4

Solo puede obtener un Instant con "nanosegundos" usando otro java.time.Clock más preciso usando el método public static Instant now(Clock clock) En su ejemplo, el reloj predeterminado normalmente usa System.currentTimeMillis () que no puede mostrar Cualquier nanosegundos.

Tenga en cuenta que no hay un reloj disponible en resolución de nanosegundos (tiempo real). La facilidad de representación interna en nanosegundos de java.time.Instant se debe principalmente al requisito de asignar las marcas de tiempo de la base de datos en precisión de nanosegundos (¡pero normalmente no es precisa en nanosegundos!).

Actualización de 2015-12-29: Java-9 entregará un mejor reloj, vea mi publicación más reciente .