Em um sistema Unix, existe uma maneira de obter um carimbo de data / hora com precisão de nível de microssegundo em Java? Algo como a gettimeofdayfunção de C.

Não, Java não tem essa capacidade.

Ele tem System.nanoTime (), mas isso apenas fornece um deslocamento de algum tempo conhecido anteriormente. Portanto, embora você não possa tirar o número absoluto disso, você pode usá-lo para medir a precisão de nanossegundos (ou superior).

Observe que o JavaDoc diz que, embora forneça precisão de nanossegundos, isso não significa precisão de nanossegundos. Portanto, pegue um módulo adequadamente grande do valor de retorno.

tl; dr

Java 9 e posterior: Resolução de até nanossegundos ao capturar o momento atual. São 9 dígitos da fração decimal.

Instant.now()   

23-12-2017T12: 34: 56.123456789Z

Para limitar a microssegundos , trunque .

Instant                // Represent a moment in UTC. 
.now()                 // Capture the current moment. Returns a `Instant` object. 
.truncatedTo(          // Lop off the finer part of this moment. 
    ChronoUnit.MICROS  // Granularity to which we are truncating. 
)                      // Returns another `Instant` object rather than changing the original, per the immutable objects pattern. 

23-12-2017T12: 34: 56.123456Z

Na prática, você verá apenas microssegundos capturados com .nowrelógios convencionais de hardware de computador contemporâneos que não são precisos em nanossegundos .

Detalhes

As outras respostas estão um tanto desatualizadas no Java 8.

java.time

Java 8 e posterior vem com a estrutura java.time . Essas novas classes substituem as classes problemáticas e problemáticas de data e hora enviadas com as versões mais antigas do Java, como java.util.Date/.Calendar e java.text.SimpleDateFormat. O framework é definido pela JSR 310, inspirado no Joda-Time , estendido pelo projeto ThreeTen-Extra.

As classes em java.time resolvem em nanossegundos , muito mais precisos do que os milissegundos usados ​​pelas antigas classes de data e hora e pelo Joda-Time. E mais fino do que os microssegundos perguntados na pergunta.

Clock Implementação

Embora as classes java.time suportem dados que representam valores em nanossegundos, as classes ainda não geram valores em nanossegundos. Os now()métodos usam a mesma implementação de relógio antigo que as classes de data e hora antigas System.currentTimeMillis(). Temos a nova Clockinterface em java.time, mas a implementação dessa interface é o mesmo relógio de milissegundos antigo.

Portanto, você pode formatar a representação textual do resultado de ZonedDateTime.now( ZoneId.of( "America/Montreal" ) )para ver nove dígitos de uma fração de segundo, mas apenas os três primeiros dígitos terão números como este:

2017-12-23T12:34:56.789000000Z

Novo relógio em Java 9

As implementações OpenJDK e Oracle do Java 9 têm uma nova Clockimplementação padrão com granularidade mais fina, até a capacidade total de nanossegundos das classes java.time.

Consulte o problema do OpenJDK, Aumente a precisão da implementação de java.time.Clock.systemUTC () . Esse problema foi implementado com sucesso.

2017-12-23T12:34:56.123456789Z

Em um MacBook Pro (Retina, 15 polegadas, final de 2013) com macOS Sierra, obtenho o momento atual em microssegundos (até seis dígitos da fração decimal).

2017-12-23T12:34:56.123456Z

Relógio de Hardware

Lembre-se de que, mesmo com uma nova Clockimplementação mais precisa, seus resultados podem variar de acordo com o computador. Java depende do relógio do hardware do computador para saber o momento atual.

• A resolução dos relógios de hardware variam amplamente. Por exemplo, se o relógio de hardware de um determinado computador suportar apenas granularidade de microssegundos , quaisquer valores de data e hora gerados terão apenas seis dígitos de frações de segundo, com os três últimos dígitos sendo zeros.
• A precisão dos relógios de hardware varia amplamente. Só porque um relógio gera um valor com vários dígitos da fração decimal de um segundo, esses dígitos podem ser imprecisos, apenas aproximações, à deriva do tempo real como podem ser lidos de um relógio atômico . Em outras palavras, só porque você vê um monte de dígitos à direita da marca decimal não significa que você pode confiar que o tempo decorrido entre essas leituras será verdadeiro para aquele grau de minuto.

Você pode usar System.nanoTime():

long start = System.nanoTime();
// do stuff
long end = System.nanoTime();
long microseconds = (end - start) / 1000;

para obter o tempo em nanossegundos, mas é uma medida estritamente relativa. Não tem significado absoluto. É útil apenas para comparação com outros nano tempos para medir quanto tempo algo demorou para fazer.

Como outros pôsteres já indicados; o relógio do sistema provavelmente não está sincronizado em microssegundos com a hora mundial real. No entanto, os carimbos de data / hora de precisão de microssegundos são úteis como um híbrido para indicar o tempo de parede atual e medir / definir o perfil da duração das coisas.

Eu rotulo todos os eventos / mensagens gravados em arquivos de log usando carimbos de data / hora como "2012-10-21 19: 13: 45.267128". Eles transmitem quando isso aconteceu (tempo de "parede") e também podem ser usados ​​para medir a duração entre este e o próximo evento no arquivo de log (diferença relativa em microssegundos).

Para conseguir isso, você precisa vincular System.currentTimeMillis () com System.nanoTime () e trabalhar exclusivamente com System.nanoTime () daquele momento em diante. Código de exemplo:

/**
 * Class to generate timestamps with microsecond precision
 * For example: MicroTimestamp.INSTANCE.get() = "2012-10-21 19:13:45.267128"
 */ 
public enum MicroTimestamp 
{  INSTANCE ;

   private long              startDate ;
   private long              startNanoseconds ;
   private SimpleDateFormat  dateFormat ;

   private MicroTimestamp()
   {  this.startDate = System.currentTimeMillis() ;
      this.startNanoseconds = System.nanoTime() ;
      this.dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;
   }

   public String get()
   {  long microSeconds = (System.nanoTime() - this.startNanoseconds) / 1000 ;
      long date = this.startDate + (microSeconds/1000) ;
      return this.dateFormat.format(date) + String.format("%03d", microSeconds % 1000) ;
   }
}

Você poderia talvez criar um componente que determina o deslocamento entre System.nanoTime () e System.currentTimeMillis () e obter efetivamente nanosegundos desde a época.

public class TimerImpl implements Timer {

    private final long offset;

    private static long calculateOffset() {
        final long nano = System.nanoTime();
        final long nanoFromMilli = System.currentTimeMillis() * 1_000_000;
        return nanoFromMilli - nano;
    }

    public TimerImpl() {
        final int count = 500;
        BigDecimal offsetSum = BigDecimal.ZERO;
        for (int i = 0; i < count; i++) {
            offsetSum = offsetSum.add(BigDecimal.valueOf(calculateOffset()));
        }
        offset = (offsetSum.divide(BigDecimal.valueOf(count))).longValue();
    }

    public long nowNano() {
        return offset + System.nanoTime();
    }

    public long nowMicro() {
        return (offset + System.nanoTime()) / 1000;
    }

    public long nowMilli() {
        return System.currentTimeMillis();
    }
}

O teste seguinte produz resultados bastante bons em minha máquina.

    final Timer timer = new TimerImpl();
    while (true) {
        System.out.println(timer.nowNano());
        System.out.println(timer.nowMilli());
    }

A diferença parece oscilar na faixa de + -3ms. Acho que é possível ajustar um pouco mais o cálculo do deslocamento.

1495065607202174413
1495065607203
1495065607202177574
1495065607203
...
1495065607372205730
1495065607370
1495065607372208890
1495065607370
...

Se você estiver interessado no Linux: Se você pescar o código-fonte para "currentTimeMillis ()", verá que, no Linux, se você chamar esse método, ele retorna um microssegundo de volta. No entanto, o Java então trunca os microssegundos e devolve milissegundos. Em parte, isso se deve ao fato de o Java ter que ser multiplataforma, então fornecer métodos específicos para o Linux era um grande problema no passado (lembra daquele suporte de soft link do 1.6 para trás ?!). Também é porque, embora seu relógio possa devolver microssegundos no Linux, isso não significa necessariamente que será bom para verificar a hora. Em níveis de microssegundos, você precisa saber que o NTP não está realinhando seu tempo e que seu relógio não mudou muito durante as chamadas de método.

Isso significa que, em teoria, no Linux, você poderia escrever um wrapper JNI igual ao do pacote System, mas sem truncar os microssegundos.

uma solução "rápida e suja" que acabei usando:

TimeUnit.NANOSECONDS.toMicros(System.nanoTime());

ATUALIZAR:

Eu usei o System.nanoTime originalmente, mas descobri que ele só deveria ser usado pelo tempo decorrido, eventualmente mudei meu código para funcionar com milissegundos ou em alguns lugares use:

TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis());

mas isso apenas adicionará zeros no final do valor (micros = millis * 1000)

Deixei esta resposta aqui como um "sinal de alerta" no caso de outra pessoa pensar em nanoTime :)

Java oferece suporte a microssegundos por meio de TimeUnitenum.

Aqui está o documento java: Enum TimeUnit

Você pode obter microssegundos em java desta maneira:

long microsenconds = TimeUnit.MILLISECONDS.toMicros(System.currentTimeMillis());

Você também pode converter microssegundos de volta em outras unidades de tempo, por exemplo:

long seconds = TimeUnit.MICROSECONDS.toSeconds(microsenconds);

Se você pretende usá-lo para o sistema em tempo real, talvez java não seja a melhor escolha para obter o carimbo de data / hora. Mas se você for usar if para a chave exclusiva, a resposta de Jason Smith será suficiente. Mas apenas no caso, para antecipar 2 itens acabam recebendo o mesmo carimbo de data / hora (é possível se esses 2 forem processados ​​quase simultaneamente), você pode fazer um loop até que o último carimbo de data / hora não seja igual ao carimbo de data / hora atual.

String timestamp = new String();
do {
    timestamp = String.valueOf(MicroTimestamp.INSTANCE.get());
    item.setTimestamp(timestamp);
} while(lasttimestamp.equals(timestamp));
lasttimestamp = item.getTimestamp();

Use o Instant para calcular microssegundos desde a época:

val instant = Instant.now();
val currentTimeMicros = instant.getEpochSecond() * 1000_000 + instant.getNano() / 1000;

LocalDateTime.now().truncatedTo(ChronoUnit.MICROS)

Aqui está um exemplo de como criar um carimbo de data / hora atual UnsignedLong:

UnsignedLong current = new UnsignedLong(new Timestamp(new Date().getTime()).getTime());