Millisecondes actuelles, de long à int

Actuellement j'ai le code suivant:

public static int currentTimeMillis()
{
    long millisLong = System.currentTimeMillis();
    while ( millisLong > Integer.MAX_VALUE )
    {
        millisLong -= Integer.MAX_VALUE;
    }
    return (int)millisLong;
}

qui renvoie l'heure courante dans un int format (pas exactement, mais il peut être utilisé pour la différence de temps). Pour de très bonnes raisons, je ne peux pas utiliser long.

Oui, je suis juste intéressé par la différence entre les deux appels, et cette approche fonctionne bien. Mais il semble tout à fait inacceptable. Je sais qu'. Et inefficaces. Je sais. Donc mes questions, comment puis-je l'améliorer?

J'ai besoin d'une fonction qui renvoie un int tels que:

int x1 = currentTimeMillis(); //my function
long y1 = System.currentTimeMillis();

.....

int x2 = currentTimeMillis();
long y2 = System.currentTimeMillis();

//here, x2 - x1 must be equal to y2 - y1

EDIT:

Pour info, je veux faire cela pour l'analyse comparative. Je suis à l'exécution de tests sur plusieurs threads en parallèle, l'événement d'arrêt est déclenché par un composant externe. Je suis aussi la sérialisation des données d'une manière qui ne prend en charge intet l'objet que je suis la sérialisation ne peut pas avoir long membres.

source d'informationauteur Luchian Grigore

  1. 26

    Votre fonction fait essentiellement la même chose que:

    public static int currentTimeMillis() {
    return (int) (System.currentTimeMillis() % Integer.MAX_VALUE);
}

    Ci-dessus est probablement ce que vous cherchez. Le le module opérateur % renvoie le reste de la division. Je tiens seulement à l'envelopper dans une autre classe qui se cache cette distance. C'est à savoir déroutant d'avoir "heure actuelle dans millis" comme un int avec la bonne valeur. Quelque chose comme:

    Stopwatch stopwatch = Stopwatch.start();

//...

int elapsed = stopwatch.elapsed();

    avec

    public final class Stopwatch {

    private long start;

    private Stopwatch() {
        start = System.currentTimeMillis();
    }

    public static Stopwatch start() {
        return new Stopwatch();
    }

    public int elapsed() {
        return (int) (System.currentTimeMillis() - start);
    }

}

    C'est aussi beaucoup mieux pour éviter les problèmes lors de l'heure de départ est à moins de Integer.MAX_VALUE et l'heure de fin est plus importante que Integer.MAX_VALUE qui donc déborde de retour à Integer.MIN_VALUE et continue à partir de là.

  2. 2

    Au lieu de trouver un module, une beaucoup plus rapide solution serait une simple opération de bits du masque de fonctionnement:

    public static int currentTimeMillis() {
    return (int) (System.currentTimeMillis() & 0x00000000FFFFFFFFL);
}
  3. 2

    Être conscient que si l' currentTimeMillis valeur survole le Integer.MAX_VALUE entre la prise de x1 et x2vous allez vous retrouver avec x2 - x1 être une valeur négative. Il y a deux façons d'aborder cette question.

    1. Utilisation BalusC de l'approche, puis lorsque vous soustrayez x2 - x1 vérifier pour voir si elle est négative. Si elle l'est, ajouter Integer.MAX_VALUE à nouveau. (Cela suppose qu'aucun des deux valeurs de temps sera vérifié que sont, en réalité, plus que Integer.MAX_VALUE distance d'intervalle).
    2. Stocker l'heure actuelle comme une private static valeur lorsque la classe est d'abord initialisé. À partir de là, de retour de la fonction de la différence entre l'heure actuelle et que les premiers temps de démarrage. Cela suppose que ces valeurs ne seront pas besoin de persister lorsque le système est redémarré, et que le système ne sera pas en vie assez longtemps pour passer le Integer.MAX_VALUE marque.

    Comme une note de côté, je suis sûr que nous nous demandons tous ce que votre très bonne raison pour ne pas utiliser long valeurs?

  4. 2

    Vous ne serez pas en mesure de satisfaire votre condition 100% du temps parce que le temps peut s'écouler entre les lignes de votre programme en cours d'exécution qui permettra de jeter les choses légèrement. Mais les chiffres ne vont pas être désactivé par beaucoup. Sans en savoir plus au sujet de votre problème, je suppose que vous n'êtes pas intéressé dans le temps réel. Peut-être vous êtes simplement intéressé au temps écoulé? Etes-vous certains de repères? Si le temps écoulé est tout ce dont vous avez besoin, le module de la solution proposée par @BalusC fera l'affaire.

  5. 2

    Il vous suffit de faire

    public static int currentTimeMillis() {
    return (int) System.currentTimeMillis();
}

    Si son négatif, il n'a pas d'importance pourvu qu'il y ait une différence. par exemple,

    int start = currentTimeMillis();

//will be positive for differences less than 24 days.
int time = currentTimeMillis() - start;

    À l'aide de cette approche éviter le problème des débordements qu'elles seront éliminées par exemple

    int start = Integer.MAX_VALUE;
//1 ms later
int time = Integer.MIN_VALUE /*due to overflow*/ - start; 
//time equals 1 due to underflow.