Java'da kronometre var mı?

Java'da kronometre var mı? Google'da yalnızca çalışmayan kronometrelerin kodunu buluyorum - her zaman 0 milisaniye döndürüyorlar.

Bulduğum bu kod çalışmıyor ama nedenini anlamıyorum.

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

İçinde bir tane bulacaksın

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

Adı

org.apache.commons.lang.time.StopWatch

Ama kabaca sizinkiyle aynı şeyi yapıyor. Daha fazla hassasiyet istiyorsanız,

System.nanoTime()

Ayrıca şu soruya buradan bakın:

Java'da zaman ölçümü ek yükü

Guava'nın Stopwatchsınıfını kullanın .

Nanosaniye cinsinden geçen zamanı ölçen bir nesne. System.nanoTime()Birkaç nedenden dolayı doğrudan çağrı yapmak yerine bu sınıfı kullanarak geçen zamanı ölçmek faydalıdır :

• Test veya performans nedenleriyle alternatif bir zaman kaynağı değiştirilebilir.
• NanoTime tarafından belgelendiği gibi, döndürülen değerin mutlak bir anlamı yoktur ve yalnızca nanoTime tarafından farklı bir zamanda döndürülen başka bir zaman damgasına göre yorumlanabilir. Kronometre daha etkili bir soyutlamadır çünkü mutlak değerleri değil, yalnızca bu göreli değerleri ortaya çıkarır.

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"

Şimdi şöyle bir şey deneyebilirsiniz:

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

Çıktı ISO 8601'de.

Yay, zarif bir org.springframework.util.StopWatchSınıf (yay-çekirdekli modül) sağlar.

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

Kullanım System.currentTimeMillis()başlangıç ve bitiş zamanını almak ve farkı hesaplamak için.

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

Bu eğiticide daha fazla bilgi

Kod çalışmıyor çünkü in geçen değişken getElapsedTimeSecs()a floatveya değil double.

Dahili Kronometre yardımcı programı yoktur, ancak JSR-310 (Java 8 Time) itibariyle bunu kolayca yapabilirsiniz.

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

Bunu doğru bir şekilde karşılaştırmadım ancak Guava'nın Kronometresini kullanmanın daha etkili olduğunu tahmin ediyorum.

http://introcs.cs.princeton.edu/java/stdlib/Stopwatch.java.html'yi deneyin

bu çok kolay

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

Bu sınıf, stdlib.jar'ın bir parçasıdır

Kutudan çıkar çıkmaz basit Kronometre sınıfı:

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

Kullanım:

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

kullanın: com.google.common.base.Stopwatch, basit ve kolaydır.

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

misal:

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

"Do something"

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

bu görev 112 değirmen aldı

bunu dene

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

Bunu dene:

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

}

Kullanım:

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

Bunu dene.

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

Kullanım:

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

Konsol:

StopWatch: 143 milliseconds.
StopWatch: 0.143 seconds.

Performetrics , tam da ihtiyacınız olan şekilde uygun bir Kronometre sınıfı sağlar. Duvar saati süresini ve daha fazlasını ölçebilir: İhtiyaç duyduğunuzda CPU süresini (kullanıcı zamanı ve sistem zamanı) da ölçer. Küçük, ücretsizdir ve Maven Central'dan indirebilirsiniz. Daha fazla bilgi ve örnek burada bulunabilir: 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  |
// +-----------------+----------------------+--------------+

Ölçüleri herhangi bir zaman birimine (nanosaniye, milisaniye, saniye, vb.) Dönüştürebilirsiniz.

Not: Aracın yazarıyım.

Burada uygun bir tane bulabilirsiniz:

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

Kullanım:

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

Bunu dene.

Java Kronometre Tam Çalışan Çözüm

Burada tamamen çalışan bir çözüm elde edeceksiniz.

Yukarıda bağlantılı çözümden sadece bir pasaj:

Aşağıdaki kod gibi bir sınıf oluşturabilir ve bu sınıfın start ve stop yöntemini kod bölümünden önce ve sonra kullanabilir, geçen zamanı ölçmek istiyorsunuz.

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.";
  }

}

Teşekkür ederim.