Mengukur Waktu yang Berlalu di Java

1. Ikhtisar

Pada artikel ini, kita akan melihat bagaimana mengukur waktu yang telah berlalu di Java. Meskipun ini mungkin terdengar mudah, ada beberapa kendala yang harus kita waspadai.

Kami akan menjelajahi kelas Java standar dan paket eksternal yang menyediakan fungsionalitas untuk mengukur waktu yang telah berlalu.

2. Pengukuran Sederhana

2.1. currentTimeMillis ()

Saat kami menemukan persyaratan untuk mengukur waktu yang telah berlalu di Java, kami dapat mencoba melakukannya seperti:

long start = System.currentTimeMillis(); // ... long finish = System.currentTimeMillis(); long timeElapsed = finish - start;

Jika kita melihat kodenya, itu masuk akal. Kami mendapatkan stempel waktu di awal dan kami mendapatkan stempel waktu lain saat kode selesai. Waktu berlalu adalah perbedaan antara kedua nilai ini.

Namun, hasilnya mungkin dan akan tidak akurat karena System.currentTimeMillis () mengukur waktu jam dinding . Waktu jam dinding dapat berubah karena berbagai alasan, misalnya mengubah waktu sistem dapat mempengaruhi hasil atau detik kabisat akan mengganggu hasil.

2.2. nanoTime ()

Metode lain di kelas java.lang.System adalah nanoTime () . Jika kita melihat dokumentasi Java, kita akan menemukan pernyataan berikut:

"Metode ini hanya dapat digunakan untuk mengukur waktu yang telah berlalu dan tidak terkait dengan gagasan lain tentang sistem atau waktu jam dinding."

Mari kita gunakan:

long start = System.nanoTime(); // ... long finish = System.nanoTime(); long timeElapsed = finish - start;

Kode tersebut pada dasarnya sama dengan sebelumnya. Satu-satunya perbedaan adalah metode yang digunakan untuk mendapatkan stempel waktu - nanoTime (), bukan currentTimeMillis () .

Perhatikan juga bahwa nanoTime () , jelas, mengembalikan waktu dalam nanodetik. Oleh karena itu, jika waktu yang berlalu diukur dalam satuan waktu yang berbeda, kita harus mengubahnya sesuai dengan itu.

Misalnya, untuk mengubah ke milidetik, kita harus membagi hasilnya dalam nanodetik dengan 1.000.000.

Perangkap lain dengan nanoTime () adalah bahwa meskipun memberikan presisi nanodetik, itu tidak menjamin resolusi nanodetik (yaitu seberapa sering nilai diperbarui).

Namun, itu menjamin bahwa resolusi akan setidaknya sebagus saat iniTimeMillis () .

3. Jawa 8

Jika kita menggunakan Java 8 - kita bisa mencoba kelas java.time.Instant dan java.time.Duration yang baru . Keduanya tidak dapat diubah, aman untuk thread, dan menggunakan skala waktunya sendiri, Java Time-Scale, seperti halnya semua kelas dalam java.time API yang baru.

3.1. Skala Waktu Java

Cara tradisional untuk mengukur waktu adalah dengan membagi satu hari menjadi 24 jam 60 menit 60 detik, yang menghasilkan 86.400 detik sehari. Namun, hari-hari matahari tidak selalu sama panjangnya.

Skala waktu UTC sebenarnya memungkinkan satu hari memiliki 86.399 atau 86.401 SI detik. Detik SI adalah "Detik Internasional Standar" ilmiah dan ditentukan oleh periode radiasi atom caesium 133). Ini diperlukan untuk menjaga hari sejajar dengan Matahari.

Skala Waktu Jawa membagi setiap hari kalender menjadi tepat 86.400 subdivisi, yang dikenal sebagai detik . Tidak ada detik kabisat.

3.2. Kelas Instan

Kelas Instan merepresentasikan instan pada timeline. Pada dasarnya, ini adalah stempel waktu numerik sejak epoch Java standar 1970-01-01T00: 00: 00Z .

Untuk mendapatkan stempel waktu saat ini, kita bisa menggunakan metode statis Instant.now () . Metode ini memungkinkan penerusan parameter Jam opsional . Jika dihilangkan, ini menggunakan jam sistem di zona waktu default.

Kita dapat menyimpan waktu mulai dan selesai dalam dua variabel, seperti pada contoh sebelumnya. Selanjutnya, kita dapat menghitung waktu yang berlalu antara kedua instan.

Kita juga bisa menggunakan kelas Duration dan metode antara () untuk mendapatkan durasi antara dua objek Instan . Terakhir, kita perlu mengonversi Durasi ke milidetik:

Instant start = Instant.now(); // CODE HERE Instant finish = Instant.now(); long timeElapsed = Duration.between(start, finish).toMillis();

4. StopWatch

Pindah ke perpustakaan, Apache Commons Lang menyediakan kelas StopWatch yang dapat digunakan untuk mengukur waktu yang telah berlalu.

4.1. Ketergantungan Maven

Kita bisa mendapatkan versi terbaru dengan memperbarui pom.xml:

 org.apache.commons commons-lang3 3.7 

Versi terbaru dari ketergantungan tersebut dapat diperiksa di sini.

4.2. Mengukur Waktu yang Berlalu Dengan StopWatch

Pertama-tama, kita perlu mendapatkan instance kelas dan kemudian kita dapat mengukur waktu yang telah berlalu:

StopWatch watch = new StopWatch(); watch.start();

Setelah kita menjalankan jam tangan, kita dapat mengeksekusi kode yang ingin kita tolak ukur dan pada akhirnya, kita cukup memanggil metode stop () . Akhirnya, untuk mendapatkan hasil aktual, kita memanggil getTime () :

watch.stop(); System.out.println("Time Elapsed: " + watch.getTime()); // Prints: Time Elapsed: 2501

StopWatch memiliki beberapa metode pembantu tambahan yang dapat kita gunakan untuk menjeda atau melanjutkan pengukuran kita. Ini mungkin berguna jika kita perlu membuat tolok ukur kita lebih kompleks.

Terakhir, perhatikan bahwa kelas tersebut tidak aman untuk thread.

5. Kesimpulan

Ada banyak cara untuk mengukur waktu di Jawa. Kami telah membahas cara yang sangat "tradisional" (dan tidak akurat) dengan menggunakan currentTimeMillis () . Selain itu, kami memeriksa StopWatch Apache Common dan melihat kelas baru yang tersedia di Java 8.

Secara keseluruhan, untuk pengukuran yang sederhana dan benar dari waktu yang telah berlalu, metode nanoTime () sudah cukup. Ini juga lebih pendek untuk diketik daripada currentTimeMillis () .

Mari perhatikan, bagaimanapun, bahwa untuk pembandingan yang tepat, daripada mengukur waktu secara manual, kita dapat menggunakan kerangka kerja seperti Java Microbenchmark Harness (JMH). Topik ini melampaui cakupan artikel ini tetapi kami menjelajahinya di sini.

Terakhir, seperti biasa, kode yang digunakan selama diskusi dapat ditemukan di GitHub.