0Pricing
Java Academy · Ders

Future ve Hata İşleme

Future.get'i zaman aşımı seçenekleriyle kullanın, ExecutionException'ı yönetin ve çalışan görevleri iptal edin.

Future ve Hata İşleme, CoddyKit'te ücretsiz bir Java Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Java Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Java Academy kursu toplamda 4 dersten oluşur.

Future Nedir?

Bir Future<V>, eşzamansız bir hesaplamanın bekleyen sonucunu temsil eder. Tamamlanma durumunu denetlemek, sonucu beklemek ve hataları ele almak için yöntemler sağlar.

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

Zaman Aşımıyla future.get()

Sonsuza kadar askıda kalmayı önlemek için her zaman zaman aşımı içeren biçimi tercih ediniz:

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

Görev bir istisna fırlattıysa future.get(), bu istisnayı ExecutionException içine sarar. getCause() ile içinden çıkarınız:

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
}

Bir Future'ı İptal Etme

cancel(mayInterruptIfRunning) görevi iptal etmeyi dener. Başarılı olursa doğru döndürür. mayInterruptIfRunning doğruysa çalışan iş parçacığına bir kesme gönderilir.

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 ile isDone Karşılaştırması

isDone(), görev normal biçimde tamamlandıysa, bir istisna fırlattıysa veya iptal edildiyse doğru döndürür. isCancelled() yalnızca görev iptal edildiyse doğru döndürür.

// 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

İlk Kullanılabilir Sonuçlar İçin CompletionService

ExecutorCompletionService bir havuzu sarar ve tamamlanan bir sonraki Future'ı almak için bir take() yöntemi sağlar (gönderilme sırasına göre değil, tamamlanma sırasına göre):

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

Birden Çok Future'ı Güvenle Ele Alma

Birçok gelecek sonuçtan sonuçları toplarken bunlar üzerinde yineleyiniz ve istisnaları her sonuç için ayrı ayrı ele alınız:

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

Havuz Kapatıldıktan Sonra Future.get()

shutdown() sonrasında gönderim yapmak RejectedExecutionException fırlatır. Ancak kapatmadan ÖNCE gönderilen gelecek sonuçlar, kapatma işleminden sonra da alınabilir:

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: El İle Future

FutureTask<V> hem Runnable hem de Future<V> arayüzlerini uygular; ExecutorService olmadan bir Future'a ihtiyaç duyduğunuzda kullanışlıdır:

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

Future ile Yeniden Deneme Deseni

future.get() çevresinde basit bir yeniden deneme mantığı uygulayınız:

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

Future'ın Sınırlamaları

java.util.concurrent.Future'ın bazı sınırlamaları vardır:

  • Geri çağrılar yoktur; get() ile engellemek gerekir
  • Dönüşümler zincirlenemez
  • Birden çok gelecek sonuç birleştirilemez

Tepkisel ve engellemesiz birleştirme için CompletableFuture kullanınız (sonraki kursta ele alınacaktır).

Hızlı Kontrol

Bir görev istisna fırlatıyor. future.get() çağrısını yaptığınızda hangi istisna fırlatılır?

Özet: Future ve Hata İşleme

Temel çıkarımlar:

  • future.get() engeller; her zaman zaman aşımı içeren biçimi kullanınız
  • ExecutionException görev istisnalarını sarar; getCause() ile içinden çıkarınız
  • cancel(true) bir kesme gönderir; durum için isDone/isCancelled kullanınız
  • ExecutorCompletionService.take() gelecek sonuçları tamamlanma sırasına göre alır
  • FutureTask hem Runnable hem de Future'ı uygular

Sıkça Sorulan Sorular

“Future ve Hata İşleme” dersi ücretsiz mi?

Evet — “Future ve Hata İşleme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Java Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Java Academy kursu toplamda 4 dersten oluşur.

“Future ve Hata İşleme” dersinde ne öğreneceğim?

Future.get'i zaman aşımı seçenekleriyle kullanın, ExecutionException'ı yönetin ve çalışan görevleri iptal edin. Java Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Java Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Java Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Future ve Hata İşleme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Java Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Java Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. ExecutorService ve İş Parçacığı Havuzu Türleri
  2. Görev Gönderme: Runnable ve Callable
  3. Future ve Hata İşleme
  4. Yinelenen Görevler için ScheduledExecutorService
← Java Academy Sayfasına Dön