scheduleAtFixedRate vs scheduleWithFixedDelay

Apa perbedaan utama antara scheduleAtFixedRatedan scheduleWithFixedDelaymetode ScheduledExecutorService ?

scheduler.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println("scheduleAtFixedRate:    " + new Date());
    }
}, 1, 3L , SECONDS);

scheduler.scheduleWithFixedDelay(new Runnable() {
    @Override
    public void run() {
        System.out.println("scheduleWithFixedDelay: " + new Date());
    }
}, 1, 3L , SECONDS);

mereka mencetak tepat pada waktu yang sama, tampaknya dijalankan pada interval yang sama persis.

Coba tambahkan Thread.sleep(1000);panggilan dalam run()metode Anda ... Pada dasarnya ini adalah perbedaan antara menjadwalkan sesuatu berdasarkan kapan eksekusi sebelumnya berakhir dan kapan itu (secara logis) dimulai .

Misalnya, saya menjadwalkan alarm untuk berbunyi dengan tarif tetap sekali dalam satu jam, dan setiap kali alarm berbunyi, saya minum secangkir kopi, yang memakan waktu 10 menit. Misalkan dimulai pada tengah malam, saya akan memiliki:

00:00: Start making coffee
00:10: Finish making coffee
01:00: Start making coffee
01:10: Finish making coffee
02:00: Start making coffee
02:10: Finish making coffee

Jika saya menjadwalkan dengan penundaan tetap selama satu jam, saya memiliki:

00:00: Start making coffee
00:10: Finish making coffee
01:10: Start making coffee
01:20: Finish making coffee
02:20: Start making coffee
02:30: Finish making coffee

Yang mana yang Anda inginkan tergantung pada tugas Anda.

Visualisasikan deret waktu scheduleAtFixedRatemetode pemanggilan . Eksekusi berikutnya akan segera dimulai jika yang terakhir membutuhkan waktu lebih lama dari periode. Jika tidak, itu akan dimulai setelah waktu periode.

Rangkaian waktu scheduleWithFixedDelaymetode pemanggilan . Eksekusi berikutnya akan dimulai setelah waktu tunda antara penghentian satu eksekusi dan dimulainya eksekusi berikutnya, terlepas dari waktu eksekusinya

Semoga dapat membantu Anda

The scheduleAtFixedRate()Metode menciptakan tugas baru dan menyerahkan ke eksekutor setiap periode, terlepas dari apakah atau tidak tugas sebelumnya selesai .

Di sisi lain, scheduleWithFixedDelay()metode ini membuat tugas baru setelah tugas sebelumnya selesai .

Jika Anda membaca Java Doc itu akan lebih jelas

ScheduledFuture scheduleAtFixedRate (Perintah Runnable, long initialDelay, periode panjang, unit TimeUnit) Membuat dan menjalankan tindakan periodik yang diaktifkan pertama setelah penundaan awal yang diberikan, dan selanjutnya dengan periode yang diberikan; Artinya, eksekusi akan dimulai setelah initialDelay lalu initialDelay + period, lalu initialDelay + 2 * periode, dan seterusnya.

ScheduledFuture scheduleWithFixedDelay (perintah Runnable, long initialDelay, long delay, unit TimeUnit) Membuat dan menjalankan tindakan periodik yang diaktifkan pertama setelah penundaan awal yang diberikan, dan kemudian dengan penundaan yang diberikan antara penghentian satu eksekusi dan dimulainya eksekusi berikutnya.

Ada satu batasan dalam scheduleAtFixedRate jika thread pertama memakan waktu terlalu lama dan tidak berakhir dalam durasi yang ditentukan, maka thread konsutif kedua tidak akan dimulai setelah tugas pertama selesai dan tidak akan segera dimulai saat thread pertama menyelesaikan tugas dan durasi yang diberikan telah berlalu. JVM akan memutuskan kapan tugas berikutnya akan dijalankan.

Saya pikir itu akan membantu Anda memilih metode karena saya mendapat masalah besar

Mari menulis program sederhana:

import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

var time = 0L
var start = System.currentTimeMillis()
val executor = Executors.newScheduledThreadPool(1)
executor.scheduleWithFixedDelay({
    if (time >= 12_000L) {
        executor.shutdown()
    } else {
        Thread.sleep(2000L)
        val now = System.currentTimeMillis()
        time += now - start
        System.out.println("Total $time delay ${now - start}\n")
        start = now
    }
}, 0L, 1000L, TimeUnit.MILLISECONDS)

Dan lihat hasilnya:

| scheduleWithFixedDelay |   scheduleAtFixedRate  |
|:----------------------:|:----------------------:|
| Total 2001 delay 2001  | Total 2003 delay 2003  |
| Total 5002 delay 3001  | Total 4004 delay 2001  |
| Total 8003 delay 3001  | Total 6004 delay 2000  |
| Total 11003 delay 3000 | Total 8004 delay 2000  |
| Total 14003 delay 3000 | Total 10005 delay 2001 |
|          ---           | Total 12005 delay 2000 |

PERHATIKAN waktu eksekusi lebih lama dari menunggu

scheduleWithFixedDelay menjaga delay
scheduleAtFixedRate menghapus penundaan

scheduledExecutorService.scheduleAtFixedRate(() -> {
        System.out.println("runnable start"); try { Thread.sleep(5000);  System.out.println("runnable end");} catch
     (InterruptedException e) { // TODO Auto-generated catch block
      e.printStackTrace(); }}, 2, 7, TimeUnit.SECONDS);



     scheduledExecutorService.scheduleWithFixedDelay(() -> {
     System.out.println("runnable start"); try { Thread.sleep(5000); System.out.println("runnable end");} catch
     (InterruptedException e) { // TODO Auto-generated catch block
     e.printStackTrace(); } }, 2, 7, TimeUnit.SECONDS);

Jalankan saja, dan Anda akan tahu perbedaannya. Terima kasih