0Pricing
Java Academy · Pelajaran

Future dan Penanganan Error

Gunakan Future.get dengan batas waktu, tangani ExecutionException, dan batalkan tugas yang sedang berjalan.

Future dan Penanganan Error adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Apa Itu Future?

Future<V> mewakili hasil tertunda dari perhitungan asinkron. Future menyediakan metode untuk memeriksa penyelesaian, menunggu hasil, dan menangani kesalahan.

import java.util.concurrent.*;

ExecutorService pool = Executors.newFixedThreadPool(2);
Future<Integer> future = pool.submit(() -> {
    Thread.sleep(1000);
    return 42;
});

System.out.println("Is done? " + future.isDone()); // false
Integer result = future.get(); // blocks
System.out.println("Result: " + result); // 42
pool.shutdown();

future.get() dengan Batas Waktu

Selalu utamakan varian dengan batas waktu untuk mencegah penantian tanpa batas:

try {
    Integer result = future.get(5, TimeUnit.SECONDS);
    System.out.println(result);
} catch (TimeoutException e) {
    System.out.println("Timed out");
    future.cancel(true); // interrupt the task
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
} catch (ExecutionException e) {
    System.out.println("Task threw: " + e.getCause());
}

ExecutionException

Jika tugas melempar pengecualian, future.get() membungkusnya dalam ExecutionException. Lepaskan pembungkusnya dengan getCause():

Future<String> failing = pool.submit(() -> {
    throw new IllegalArgumentException("bad input");
});

try {
    failing.get();
} catch (ExecutionException e) {
    Throwable cause = e.getCause();
    System.out.println(cause.getClass().getSimpleName()); // IllegalArgumentException
    System.out.println(cause.getMessage()); // bad input
}

Membatalkan Future

cancel(mayInterruptIfRunning) mencoba membatalkan tugas. Metode ini mengembalikan true jika berhasil. Jika mayInterruptIfRunning bernilai true, interupsi dikirim ke utas yang sedang berjalan.

Future<String> f = pool.submit(() -> {
    try {
        Thread.sleep(10_000); // long task
        return "done";
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return "interrupted";
    }
});

boolean cancelled = f.cancel(true); // send interrupt
System.out.println("Cancelled: " + cancelled); // true
System.out.println("Is cancelled: " + f.isCancelled()); // true

isCancelled vs isDone

isDone() mengembalikan true jika tugas selesai secara normal, melempar pengecualian, atau dibatalkan. isCancelled() hanya mengembalikan true jika tugas dibatalkan.

// After cancel:
System.out.println(f.isDone());       // true
System.out.println(f.isCancelled()); // true

// After normal completion:
Future<Integer> done = pool.submit(() -> 5);
done.get(); // wait
System.out.println(done.isDone());       // true
System.out.println(done.isCancelled()); // false

CompletionService untuk Hasil yang Tersedia Pertama

ExecutorCompletionService membungkus kumpulan utas dan menyediakan metode take() untuk mengambil Future berikutnya yang selesai (berdasarkan urutan penyelesaian, bukan urutan pengiriman):

ExecutorCompletionService<Integer> cs =
    new ExecutorCompletionService<>(pool);

for (int i = 0; i < 5; i++) {
    final int delay = 5 - i; // submit fastest last
    cs.submit(() -> { Thread.sleep(delay * 100); return delay; });
}

for (int i = 0; i < 5; i++) {
    Future<Integer> f = cs.take(); // next completed
    System.out.println(f.get());
}

Menangani Beberapa Future dengan Aman

Saat mengumpulkan hasil dari banyak future, lakukan iterasi dan tangani pengecualian untuk setiap future:

List<Future<String>> futures = new ArrayList<>();
for (int i = 0; i < 5; i++) {
    final int id = i;
    futures.add(pool.submit(() ->
        id % 2 == 0 ? "ok_" + id : (() -> { throw new RuntimeException("fail_"+id); }).get()
    ));
}

for (Future<String> f : futures) {
    try {
        System.out.println(f.get());
    } catch (ExecutionException e) {
        System.out.println("Error: " + e.getCause().getMessage());
    }
}

Future.get() Setelah Kumpulan Utas Dihentikan

Pengiriman setelah shutdown() melempar RejectedExecutionException. Namun, Future yang dikirim SEBELUM penghentian masih dapat diambil setelah penghentian:

ExecutorService pool2 = Executors.newFixedThreadPool(2);
Future<Integer> f = pool2.submit(() -> 99);
pool2.shutdown(); // no new tasks

// Still valid — task was submitted before shutdown:
System.out.println(f.get()); // 99

try {
    pool2.submit(() -> 0); // throws!
} catch (RejectedExecutionException e) {
    System.out.println("Pool shut down");
}

FutureTask: Future Manual

FutureTask<V> mengimplementasikan Runnable dan Future<V> sekaligus—berguna saat Anda memerlukan Future tanpa ExecutorService:

FutureTask<String> task = new FutureTask<>(() -> "computed");
new Thread(task).start(); // run in any thread
System.out.println(task.get()); // computed

Pola Percobaan Ulang dengan Future

Implementasikan logika percobaan ulang sederhana di sekitar future.get():

Future<String> future = pool.submit(() -> {
    if (Math.random() < 0.7) throw new RuntimeException("transient error");
    return "success";
});

for (int attempt = 0; attempt < 3; attempt++) {
    try {
        System.out.println(future.get());
        break;
    } catch (ExecutionException e) {
        System.out.println("Attempt " + (attempt+1) + " failed");
        if (attempt == 2) throw e;
        future = pool.submit(() -> "retry"); // resubmit
    }
}

Keterbatasan Future

java.util.concurrent.Future memiliki beberapa keterbatasan:

  • Tidak memiliki panggilan balik—harus memblokir dengan get()
  • Tidak dapat merangkai transformasi
  • Tidak dapat menggabungkan beberapa future

Gunakan CompletableFuture (kursus berikutnya) untuk komposisi reaktif tanpa pemblokiran.

Pemeriksaan Singkat

Suatu tugas melempar pengecualian. Pengecualian apa yang dilempar saat Anda memanggil future.get()?

Ringkasan: Future dan Penanganan Kesalahan

Inti penting:

  • future.get() memblokir; selalu gunakan varian dengan batas waktu
  • ExecutionException membungkus pengecualian tugas; lepaskan pembungkusnya dengan getCause()
  • cancel(true) mengirimkan interupsi; gunakan isDone/isCancelled untuk memeriksa status
  • ExecutorCompletionService.take() mengambil Future berdasarkan urutan penyelesaian
  • FutureTask mengimplementasikan Runnable dan Future sekaligus

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Future dan Penanganan Error” gratis?

Ya — teks lengkap “Future dan Penanganan Error” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Future dan Penanganan Error”?

Gunakan Future.get dengan batas waktu, tangani ExecutionException, dan batalkan tugas yang sedang berjalan. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Future dan Penanganan Error” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. ExecutorService dan Tipe Kumpulan Thread
  2. Mengirimkan Tugas: Runnable vs Callable
  3. Future dan Penanganan Error
  4. ScheduledExecutorService untuk Tugas Berulang
← Kembali ke Java Academy