Berjangka
Futures diperkenalkan di Java 5 (2004). Mereka pada dasarnya adalah penampung untuk hasil operasi yang belum selesai. Setelah operasi selesai, Futureakan berisi hasil itu. Sebagai contoh, suatu operasi bisa menjadi contoh Runnable atau Callable yang dikirimkan ke ExecutorService . Pengirim operasi dapat menggunakan Futureobjek untuk memeriksa apakah operasi itu dilakukan () , atau menunggu sampai selesai menggunakan metode blocking get () .
Contoh:
/**
* A task that sleeps for a second, then returns 1
**/
public static class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
Thread.sleep(1000);
return 1;
}
}
public static void main(String[] args) throws Exception{
ExecutorService exec = Executors.newSingleThreadExecutor();
Future<Integer> f = exec.submit(new MyCallable());
System.out.println(f.isDone()); //False
System.out.println(f.get()); //Waits until the task is done, then prints 1
}
CompletableFutures
CompletableFutures diperkenalkan di Java 8 (2014). Mereka sebenarnya merupakan evolusi Futures biasa, terinspirasi oleh Google's Listenable Futures , bagian dari perpustakaan Guava . Mereka adalah Futures yang juga memungkinkan Anda untuk merangkai tugas bersama dalam sebuah rantai. Anda dapat menggunakannya untuk memberi tahu beberapa utas pekerja untuk "lakukan tugas X, dan setelah selesai, lakukan hal lain ini menggunakan hasil X". Menggunakan CompletableFutures, Anda dapat melakukan sesuatu dengan hasil operasi tanpa benar-benar memblokir utas untuk menunggu hasilnya. Berikut ini contoh sederhana:
/**
* A supplier that sleeps for a second, and then returns one
**/
public static class MySupplier implements Supplier<Integer> {
@Override
public Integer get() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//Do nothing
}
return 1;
}
}
/**
* A (pure) function that adds one to a given Integer
**/
public static class PlusOne implements Function<Integer, Integer> {
@Override
public Integer apply(Integer x) {
return x + 1;
}
}
public static void main(String[] args) throws Exception {
ExecutorService exec = Executors.newSingleThreadExecutor();
CompletableFuture<Integer> f = CompletableFuture.supplyAsync(new MySupplier(), exec);
System.out.println(f.isDone()); // False
CompletableFuture<Integer> f2 = f.thenApply(new PlusOne());
System.out.println(f2.get()); // Waits until the "calculation" is done, then prints 2
}
RxJava
RxJava adalah seluruh perpustakaan untuk pemrograman reaktif yang dibuat di Netflix. Sepintas, sepertinya akan mirip dengan aliran Java 8 . Ya, kecuali itu jauh lebih kuat.
Demikian pula untuk Futures, RxJava dapat digunakan untuk merangkai sekelompok tindakan sinkron atau asinkron untuk membuat pipa pemrosesan. Tidak seperti Futures, yang merupakan sekali pakai, RxJava bekerja pada aliran nol atau lebih item. Termasuk aliran yang tidak pernah berakhir dengan jumlah item yang tak terbatas. Ini juga jauh lebih fleksibel dan kuat berkat serangkaian operator yang luar biasa kaya .
Tidak seperti stream Java 8, RxJava juga memiliki mekanisme tekanan balik , yang memungkinkannya untuk menangani kasus di mana berbagai bagian dari pipa pemrosesan Anda beroperasi di utas yang berbeda, dengan laju yang berbeda .
Kelemahan dari RxJava adalah bahwa meskipun dokumentasi yang solid, ini adalah perpustakaan yang menantang untuk dipelajari karena perubahan paradigma yang terlibat. Kode Rx juga bisa menjadi mimpi buruk untuk debug, terutama jika beberapa utas terlibat, dan bahkan lebih buruk - jika tekanan balik diperlukan.
Jika Anda ingin masuk ke dalamnya, ada seluruh halaman berbagai tutorial di situs web resmi, ditambah dokumentasi resmi dan Javadoc . Anda juga dapat melihat beberapa video seperti ini yang memberikan intro singkat ke Rx dan juga berbicara tentang perbedaan antara Rx dan Futures.
Bonus: Java 9 Streaming Reaktif
Java 9's Reactive Streams alias Flow API adalah seperangkat Antarmuka yang diimplementasikan oleh berbagai perpustakaan aliran reaktif seperti RxJava 2 , Akka Streams , dan Vertx . Mereka memungkinkan pustaka reaktif ini untuk saling berhubungan, sambil mempertahankan semua tekanan balik yang penting.