Gibt es eine Stoppuhr in Java?

Gibt es eine Stoppuhr in Java? Bei Google finde ich nur Code von Stoppuhren, die nicht funktionieren - sie geben immer 0 Millisekunden zurück.

Dieser Code, den ich gefunden habe, funktioniert nicht, aber ich verstehe nicht warum.

public class StopWatch {

  private long startTime = 0;
  private long stopTime = 0;
  private boolean running = false;


  public void start() {
    this.startTime = System.currentTimeMillis();
    this.running = true;
  }


  public void stop() {
    this.stopTime = System.currentTimeMillis();
    this.running = false;
  }


  //elaspsed time in milliseconds
  public long getElapsedTime() {
    long elapsed;
    if (running) {
      elapsed = (System.currentTimeMillis() - startTime);
    } else {
      elapsed = (stopTime - startTime);
    }
    return elapsed;
  }


  //elaspsed time in seconds
  public long getElapsedTimeSecs() {
    long elapsed;
    if (running) {
      elapsed = ((System.currentTimeMillis() - startTime) / 1000);
    } else {
      elapsed = ((stopTime - startTime) / 1000);
    }
    return elapsed;
  }
}

Sie finden einen in

http://commons.apache.org/lang/

Es heißt

org.apache.commons.lang.time.StopWatch

Aber es macht ungefähr das Gleiche wie deins. Wenn Sie mehr Präzision wünschen, verwenden Sie

System.nanoTime()

Siehe auch diese Frage hier:

Zeitmessaufwand in Java

Verwenden Sie die StopwatchKlasse von Guava .

Ein Objekt, das die verstrichene Zeit in Nanosekunden misst. Es ist System.nanoTime()aus mehreren Gründen nützlich, die verstrichene Zeit mit dieser Klasse zu messen, anstatt direkt aufzurufen :

• Eine alternative Zeitquelle kann aus Test- oder Leistungsgründen ersetzt werden.
• Wie von nanoTime dokumentiert, hat der zurückgegebene Wert keine absolute Bedeutung und kann nur als relativ zu einem anderen Zeitstempel interpretiert werden, der von nanoTime zu einem anderen Zeitpunkt zurückgegeben wird. Stoppuhr ist eine effektivere Abstraktion, da nur diese relativen Werte verfügbar gemacht werden, nicht die absoluten.

Stopwatch stopwatch = Stopwatch.createStarted();
doSomething();
stopwatch.stop(); // optional

long millis = stopwatch.elapsed(TimeUnit.MILLISECONDS);

log.info("that took: " + stopwatch); // formatted string like "12.3 ms"

Jetzt können Sie etwas ausprobieren wie:

Instant starts = Instant.now();
Thread.sleep(10);
Instant ends = Instant.now();
System.out.println(Duration.between(starts, ends));

Die Ausgabe erfolgt in ISO 8601.

Die Feder bietet eine elegante org.springframework.util.StopWatchKlasse (Federkernmodul).

StopWatch stopWatch = new StopWatch();
stopWatch.start();
     // Do something
stopWatch.stop();
     System.out.println(stopWatch.getTotalTimeMillis());

Verwenden Sie System.currentTimeMillis()diese Option , um die Start- und Endzeit abzurufen und die Differenz zu berechnen.

class TimeTest1 {
  public static void main(String[] args) {

    long startTime = System.currentTimeMillis();

    long total = 0;
    for (int i = 0; i < 10000000; i++) {
      total += i;
    }

    long stopTime = System.currentTimeMillis();
    long elapsedTime = stopTime - startTime;
    System.out.println(elapsedTime);
  }
} 

Weitere Infos in diesem Tutorial

Der Code funktioniert nicht, da die verstrichene Variable in getElapsedTimeSecs()kein floatoder ist double.

Es gibt kein eingebautes Stoppuhr-Dienstprogramm, aber ab JSR-310 (Java 8 Time) können Sie dies einfach tun.

ZonedDateTime now = ZonedDateTime.now();
// Do stuff
long seconds = now.until(ZonedDateTime.now(), ChronoUnit.SECONDS);

Ich habe dies nicht richtig bewertet, aber ich würde vermuten, dass die Verwendung der Stoppuhr von Guava effektiver ist.

Versuchen Sie dies http://introcs.cs.princeton.edu/java/stdlib/Stopwatch.java.html

das ist sehr einfach

Stopwatch st = new Stopwatch();
// Do smth. here
double time = st.elapsedTime(); // the result in millis

Diese Klasse ist Teil von stdlib.jar

Einfache sofort einsatzbereite Stoppuhrklasse:

import java.time.Duration;
import java.time.Instant;

public class StopWatch {

    Instant startTime, endTime;
    Duration duration;
    boolean isRunning = false;

    public void start() {
        if (isRunning) {
            throw new RuntimeException("Stopwatch is already running.");
        }
        this.isRunning = true;
        startTime = Instant.now();
    }

    public Duration stop() {
        this.endTime = Instant.now();
        if (!isRunning) {
            throw new RuntimeException("Stopwatch has not been started yet");
        }
        isRunning = false;
        Duration result = Duration.between(startTime, endTime);
        if (this.duration == null) {
            this.duration = result;
        } else {
            this.duration = duration.plus(result);
        }

        return this.getElapsedTime();
    }

    public Duration getElapsedTime() {
        return this.duration;
    }

    public void reset() {
        if (this.isRunning) {
            this.stop();
        }
        this.duration = null;
    }
}

Verwendung:

StopWatch sw = new StopWatch();
sw.start();
    // doWork()
sw.stop();
System.out.println( sw.getElapsedTime().toMillis() + "ms");

Verwenden Sie: com.google.common.base.Stopwatch, es ist einfach und leicht.

<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>23.0</version>
</dependency>

Beispiel:

Stopwatch stopwatch = new Stopwatch();
stopwatch.start();

"Do something"

logger.debug("this task took " + stopwatch.stop().elapsedTime(TimeUnit.MILLISECONDS) + " mills");

Diese Aufgabe dauerte 112 Mühlen

Versuche dies

import java.awt.event.*;

import java.awt.*;

import javax.swing.*;

public class millis extends JFrame implements ActionListener, Runnable
    {

     private long startTime;
     private final static java.text.SimpleDateFormat timerFormat = new java.text.SimpleDateFormat("mm : ss.SSS");
     private final JButton startStopButton= new JButton("Start/stop");
     private Thread updater;
     private boolean isRunning= false;
     private final Runnable displayUpdater= new Runnable()
         {
         public void run()
             {
             displayElapsedTime(System.currentTimeMillis() - millis.this.startTime);
         }
     };
     public void actionPerformed(ActionEvent ae)
         {
         if(isRunning)
             {
             long elapsed= System.currentTimeMillis() - startTime;
             isRunning= false;
             try
                 {
                 updater.join();
                 // Wait for updater to finish
             }
             catch(InterruptedException ie) {}
             displayElapsedTime(elapsed);
             // Display the end-result
         }
         else
             {
             startTime= System.currentTimeMillis();
             isRunning= true;
             updater= new Thread(this);
             updater.start();
         }
     }
     private void displayElapsedTime(long elapsedTime)
         {
         startStopButton.setText(timerFormat.format(new java.util.Date(elapsedTime)));
     }
     public void run()
         {
         try
             {
             while(isRunning)
                 {
                 SwingUtilities.invokeAndWait(displayUpdater);
                 Thread.sleep(50);
             }
         }
         catch(java.lang.reflect.InvocationTargetException ite)
             {
             ite.printStackTrace(System.err);
             // Should never happen!
         }
         catch(InterruptedException ie) {}
         // Ignore and return!
     }
     public millis()
         {
         startStopButton.addActionListener(this);
         getContentPane().add(startStopButton);
         setSize(100,50);
         setVisible(true);
     }
     public static void main(String[] arg)
         {
         new Stopwatch().addWindowListener(new WindowAdapter()
             {
             public void windowClosing(WindowEvent e)
                 {
                 System.exit(0);
             }
         });
         millis s=new millis();
         s.run();
     }
}

Versuche dies:

/*
 * calculates elapsed time in the form hrs:mins:secs
 */
public class StopWatch
{ 
    private Date startTime;

    public void startTiming()
    {
        startTime = new Date();
    }

    public String stopTiming()
    {
        Date stopTime = new Date();
        long timediff = (stopTime.getTime() - startTime.getTime())/1000L;
        return(DateUtils.formatElapsedTime(timediff));
    }

}

Verwenden:

StopWatch sw = new StopWatch();
...
sw.startTiming();
...
String interval = sw.stopTiming();

Versuche dies.

public class StopWatch { 

      private long startTime = 0;
      private long stopTime = 0;

      public StopWatch()
      {
            startTime = System.currentTimeMillis();
      }

      public void start() {
        startTime = System.currentTimeMillis();
      }

      public void stop() {
        stopTime = System.currentTimeMillis();
        System.out.println("StopWatch: " + getElapsedTime() + " milliseconds.");
        System.out.println("StopWatch: " + getElapsedTimeSecs() + " seconds.");
      }

      /**
       * @param process_name
       */
      public void stop(String process_name) {
            stopTime = System.currentTimeMillis();
            System.out.println(process_name + " StopWatch: " + getElapsedTime() + " milliseconds.");
            System.out.println(process_name + " StopWatch: " + getElapsedTimeSecs() + " seconds.");
      }      

      //elaspsed time in milliseconds
      public long getElapsedTime() {
          return stopTime - startTime;
      }

      //elaspsed time in seconds
      public double getElapsedTimeSecs() {
        double elapsed;
          elapsed = ((double)(stopTime - startTime)) / 1000;
        return elapsed;
      }
} 

Verwendung:

StopWatch watch = new StopWatch();
// do something
watch.stop();

Konsole:

StopWatch: 143 milliseconds.
StopWatch: 0.143 seconds.

Performetrics bietet eine praktische Stoppuhrklasse, genau so, wie Sie es brauchen. Es kann die Wanduhrzeit und mehr messen: Bei Bedarf misst es auch die CPU-Zeit (Benutzerzeit und Systemzeit). Es ist klein, kostenlos und kann von Maven Central heruntergeladen werden. Weitere Informationen und Beispiele finden Sie hier: https://obvj.net/performetrics

Stopwatch sw = new Stopwatch();
sw.start();

// Your code

sw.stop();
sw.printStatistics(System.out);

// Sample output:
// +-----------------+----------------------+--------------+
// | Counter         |         Elapsed time | Time unit    |
// +-----------------+----------------------+--------------+
// | Wall clock time |             85605718 | nanoseconds  |
// | CPU time        |             78000500 | nanoseconds  |
// | User time       |             62400400 | nanoseconds  |
// | System time     |             15600100 | nanoseconds  |
// +-----------------+----------------------+--------------+

Sie können die Metriken in jede Zeiteinheit konvertieren (Nanosekunden, Millisekunden, Sekunden usw.)

PS: Ich bin der Autor des Tools.

Eine bequeme finden Sie hier:

https://github.com/varra4u/utils4j/blob/master/src/main/java/com/varra/util/StopWatch.java

Verwendung:

final StopWatch timer = new StopWatch();
System.out.println("Timer: " + timer);
System.out.println("ElapsedTime: " + timer.getElapsedTime());

Versuche dies.

Java Stopwatch voll funktionsfähige Lösung

Hier erhalten Sie eine voll funktionsfähige Lösung.

Nur ein Ausschnitt aus der oben verlinkten Lösung:

Sie können eine Klasse wie den folgenden Code erstellen und die Start- und Stoppmethode dieser Klasse vor und nach dem Codeabschnitt verwenden, um die benötigte Zeit zu messen.

public class Stopwatch{
  private long startTime;
  private long stopTime;

  /**
   starting the stop watch.
  */
  public void start(){
        startTime = System.nanoTime();
  }

  /**
   stopping the stop watch.
  */
  public void stop()
  {     stopTime = System.nanoTime(); }

  /**
  elapsed time in nanoseconds.
  */
  public long time(){
        return (stopTime - startTime);
  }

  public String toString(){
      return "elapsed time: " + time() + " nanoseconds.";
  }

}}

Danke dir.