comme d'autres posters l'ont déjà indiqué; votre horloge système n'est probablement pas synchronisée jusqu'à microsecondes avec l'heure réelle du monde. Néanmoins, les chronomètres de précision microsecondes sont utiles en tant qu'hybride à la fois pour indiquer le temps de paroi actuel et pour mesurer/profiler la durée des choses.

je l'étiquette de tous les événements, les messages écrits dans un journal de fichiers à l'aide des horodateurs, comme "2012-10-21 19:13:45.267128". Ceux-ci véhiculent à la fois quand il s'est produit ("Mur" Temps), et peut également être utilisé pour mesurer la durée entre cet événement et le suivant dans le fichier log (différence relative en microsecondes).

pour ce faire, vous devez relier le système.currentTimeMillis () avec System.nanoTime() et travaille exclusivement avec System.nanoTime() à partir de ce moment-là. Exemple de code:

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

si vous êtes intéressé par Linux: Si vous épluchez le code source de "currentTimeMillis()", vous verrez que, sur Linux, si vous appelez cette méthode, elle obtient un temps de microseconde en arrière. Cependant, Java tronque ensuite les microsecondes et vous renvoie des millisecondes. Cela s'explique en partie par le fait que Java doit être une plate-forme croisée, de sorte que fournir des méthodes spécifiquement pour Linux était un grand non-pas à l'époque (rappelez-vous que le support de liens mous cruddy de 1.6 à l'envers?!). C'est aussi parce que, pendant que vous chronométrez peut vous donner en retour des microsecondes sous Linux, cela ne signifie pas nécessairement qu'il sera bon de vérifier l'heure. Au niveau de la microseconde, vous devez savoir que le NTP ne réaligne pas votre temps et que votre horloge n'a pas trop dérivé pendant les appels de méthode.

cela signifie, en théorie, que sur Linux, vous pouvez écrire un wrapper JNI qui est le même que celui du paquet système, mais qui ne tronque pas les microsecondes.

un "rapide et sale" la solution que j'ai finalement fait avec:

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

mise à jour:

j'ai utilisé le système à l'origine.nanoTime mais ensuite j'ai découvert qu'il ne devait être utilisé que pour le temps écoulé, j'ai finalement changé mon code pour travailler avec des millisecondes ou à certains endroits utiliser:

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

mais cela ajoutera juste des zéros à la fin de la valeur (micros = millidis * 1000)

a laissé cette réponse ici comme un "signe d'alerte" dans le cas où quelqu'un d'autre pense de nanoTime :)

Java support microsecondes à travers TimeUnit enum.

voici le doc java: Enum TimeUnit

vous pouvez obtenir des microsecondes en java de cette façon:

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

vous pouvez également convertir des microsecondes à d'autres unités de temps, par exemple:

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

si vous avez l'intention de l'utiliser pour le système en temps réel, peut-être que java n'est pas le meilleur choix pour obtenir l'horodatage. Mais si vous allez utiliser si pour la clé unique, alors la réponse de Jason Smith en fera assez. Mais juste au cas où, pour anticiper 2 item finissent par obtenir le même timestamp (c'est possible si ces 2 ont été traités presque simultanément), vous pouvez boucler jusqu'à ce que le dernier timestamp n'égale pas avec le timestamp actuel.

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

vous pourriez peut-être créer un composant qui détermine le décalage entre les systèmes.nanoTime() et du Système.currentTimeMillis() et efficacement obtenir de nanosecondes depuis l'époque.

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

après le test produit des résultats assez bons sur ma machine.

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

la différence semble osciller dans la gamme de +-3ms. Je pense que l'on pourrait modifier un peu plus le calcul de l'offset.

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

voici un exemple de la façon de créer une estampille de temps courante Non signée:

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