Czy w systemie Unix można uzyskać znacznik czasu z dokładnością do mikrosekund w języku Java? Coś w rodzaju gettimeofdayfunkcji C.

Nie, Java nie ma takiej możliwości.

Ma System.nanoTime (), ale to po prostu daje przesunięcie w stosunku do wcześniej znanego czasu. Więc chociaż nie możesz wziąć z tego absolutnej liczby, możesz użyć jej do pomiaru precyzji nanosekundowej (lub wyższej).

Zauważ, że JavaDoc mówi, że chociaż zapewnia to precyzję nanosekundową, nie oznacza to dokładności nanosekundowej. Więc weź odpowiednio duży moduł wartości zwracanej.

tl; dr

Java 9 i nowsze: rozdzielczość do nanosekund podczas rejestrowania bieżącego momentu. To 9 cyfr ułamka dziesiętnego.

Instant.now()   

2017-12-23T12: 34: 56.123456789Z

Aby ograniczyć do mikrosekund , obetnij .

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. 

2017-12-23T12: 34: 56.123456Z

W praktyce zobaczysz uchwycone tylko mikrosekundy, .nowponieważ współczesne konwencjonalne zegary sprzętu komputerowego nie są dokładne w nanosekundach .

Detale

Pozostałe odpowiedzi są nieco nieaktualne od wersji Java 8.

java.time

Java 8 i nowsze są dostarczane ze strukturą java.time . Te nowe klasy zastępują wadliwe, kłopotliwe klasy daty i czasu dostarczane z najwcześniejszymi wersjami języka Java, takie jak java.util.Date/.Calendar i java.text.SimpleDateFormat. Framework definiuje JSR 310, zainspirowany Joda-Time , rozszerzony o projekt ThreeTen-Extra.

Klasy w java.time są rozwiązywane do nanosekund , znacznie dokładniejszych niż milisekundy używane zarówno przez stare klasy daty i godziny, jak i przez Joda-Time. I dokładniejszy niż mikrosekundy zadane w pytaniu.

Clock Realizacja

Chociaż klasy java.time obsługują dane reprezentujące wartości w nanosekundach, klasy nie generują jeszcze wartości w nanosekundach. Te now()metody użyć tego samego starego zegara jako realizację dawnych klas data-czasowych System.currentTimeMillis(). Mamy nowy Clockinterfejs w java.time, ale implementacja tego interfejsu to ten sam stary zegar milisekundowy.

Więc możesz sformatować tekstową reprezentację wyniku, ZonedDateTime.now( ZoneId.of( "America/Montreal" ) )aby zobaczyć dziewięć cyfr ułamka sekundy, ale tylko pierwsze trzy cyfry będą miały liczby takie jak ta:

2017-12-23T12:34:56.789000000Z

Nowy zegar w Javie 9

Implementacje OpenJDK i Oracle Java 9 mają nową domyślną Clockimplementację z większą szczegółowością, aż do pełnej nanosekundowej możliwości klas java.time.

Zobacz kwestię OpenJDK, Zwiększ precyzję implementacji java.time.Clock.systemUTC () . Ten problem został pomyślnie wdrożony.

2017-12-23T12:34:56.123456789Z

Na MacBooku Pro (Retina, 15-calowym, koniec 2013 r.) Z macOS Sierra otrzymuję aktualny moment w mikrosekundach (do sześciu cyfr ułamka dziesiętnego).

2017-12-23T12:34:56.123456Z

Zegar sprzętowy

Pamiętaj, że nawet przy nowej, lepszej Clockimplementacji, wyniki mogą się różnić w zależności od komputera. Java jest zależna od zegara sprzętu komputerowego, aby poznać aktualny moment.

• Rozdzielczość zegarów sprzętowe są bardzo zróżnicowane. Na przykład, jeśli zegar sprzętowy konkretnego komputera obsługuje dokładność tylko w mikrosekundach , wszelkie wygenerowane wartości daty i godziny będą miały tylko sześć cyfr ułamka sekundy, a ostatnie trzy cyfry będą zerami.
• Dokładność zegarów sprzętowe są bardzo zróżnicowane. Tylko dlatego, że zegar generuje wartość z kilkoma cyframi dziesiętnego ułamka sekundy, cyfry te mogą być niedokładne, tylko przybliżone, odbiegające od rzeczywistego czasu, które można odczytać z zegara atomowego . Innymi słowy, tylko dlatego, że widzisz kilka cyfr po prawej stronie znaku dziesiętnego, nie oznacza, że ​​możesz ufać, że czas, który upłynął między takimi odczytami, będzie zgodny z tym minutowym stopniem.

Możesz użyć System.nanoTime():

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

aby uzyskać czas w nanosekundach, ale jest to miara ściśle względna. Nie ma absolutnego znaczenia. Przydaje się tylko do porównania z innymi nanoczasami, aby zmierzyć, jak długo coś trwało.

Jak już wskazywały inne plakaty; Twój zegar systemowy prawdopodobnie nie jest zsynchronizowany do mikrosekund z rzeczywistym czasem światowym. Niemniej jednak znaczniki czasu z dokładnością do mikrosekund są przydatne jako hybryda zarówno do wskazywania aktualnego czasu ściany, jak i do pomiaru / profilowania czasu trwania rzeczy.

Oznaczam wszystkie zdarzenia / wiadomości zapisane w plikach dziennika za pomocą sygnatur czasowych, takich jak „2012-10-21 19: 13: 45.267128”. Wskazują one zarówno kiedy to się wydarzyło (czas „ściany”), jak i mogą być również użyte do pomiaru czasu trwania między tym a następnym zdarzeniem w pliku dziennika (względna różnica w mikrosekundach).

Aby to osiągnąć, musisz połączyć System.currentTimeMillis () z System.nanoTime () i od tego momentu pracować wyłącznie z System.nanoTime (). Przykładowy kod:

/**
 * 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) ;
   }
}

Możesz utworzyć komponent, który określa przesunięcie między System.nanoTime () i System.currentTimeMillis () i efektywnie uzyskać nanosekundy od epoki.

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();
    }
}

Poniższy test daje dość dobre wyniki na moim komputerze.

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

Różnica wydaje się oscylować w przedziale + -3 ms. Wydaje mi się, że można by nieco bardziej podkręcić obliczenia przesunięcia.

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

Jeśli interesuje Cię Linux: Jeśli wyłowisz kod źródłowy do „currentTimeMillis ()”, zobaczysz, że wywołanie tej metody w Linuksie powoduje cofnięcie się o mikrosekundę. Jednak Java skraca następnie mikrosekundy i zwraca milisekundy. Dzieje się tak częściowo dlatego, że Java musi być wieloplatformowa, więc dostarczanie metod specjalnie dla Linuksa było wielkim nie-nie w tamtych czasach (pamiętajcie, że obsługa linków miękkich od wersji 1.6 wstecz ?!) Dzieje się tak również dlatego, że chociaż zegar w Linuksie może zwracać mikrosekundy, niekoniecznie oznacza to, że będzie dobry do sprawdzania czasu. Na poziomach mikrosekund musisz wiedzieć, że NTP nie wyrównuje twojego czasu i że twój zegar nie dryfował zbytnio podczas wywołań metod.

Oznacza to, że teoretycznie w systemie Linux można napisać opakowanie JNI, które jest takie samo jak w pakiecie System, ale nie skracać mikrosekund.

„szybkie i brudne” rozwiązanie, które ostatecznie wybrałem:

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

AKTUALIZACJA:

Początkowo korzystałem z System.nanoTime, ale potem odkryłem, że powinien być używany tylko przez upływający czas, ostatecznie zmieniłem kod, aby działał z milisekundami lub w niektórych miejscach używam:

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

ale to po prostu doda zera na końcu wartości (micros = millis * 1000)

Zostawiłem tę odpowiedź tutaj jako „znak ostrzegawczy” na wypadek, gdyby ktoś pomyślał o nanoTime :)

Obsługa języka Java w mikrosekundach przez TimeUnitwyliczenie.

Oto dokument java: Enum TimeUnit

Możesz uzyskać mikrosekundy w Javie w ten sposób:

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

Możesz także przekonwertować mikrosekundy z powrotem na inne jednostki czasu, na przykład:

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

Jeśli zamierzasz używać go w systemie czasu rzeczywistego, być może java nie jest najlepszym wyborem, aby uzyskać znacznik czasu. Ale jeśli zamierzasz użyć klucza if dla unikalnego klucza, odpowiedź Jasona Smitha wystarczy. Ale na wszelki wypadek, aby przewidzieć, że 2 elementy otrzymają ten sam znacznik czasu (jest to możliwe, jeśli te 2 zostały przetworzone prawie jednocześnie), możesz zapętlić, aż ostatni znacznik czasu nie będzie równy bieżącemu znacznikowi czasu.

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

Użyj funkcji Instant, aby obliczyć mikrosekundy od Epoki:

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

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

Oto przykład sposobu tworzenia UnsignedLong current Timestamp:

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