Diskusi singkat tentang penggunaan Callable dan Masa Depan untuk Pemrograman Paralel di Java

Pemrograman Paralel Menggunakan Callable dan Masa Depan

Cara paling umum untuk melakukan pemrograman paralel di Java adalah dengan mewarisi kelas utas atau mengimplementasikan antarmuka yang dapat dijalankan. Kerugian dari kedua metode ini adalah bahwa hasil eksekusi tidak dapat diperoleh secara langsung setelah tugas selesai, dan harus dikomunikasikan melalui variabel bersama atau antar-thread, yang tidak nyaman digunakan.

Mulai dari Java 1.5, antarmuka yang dapat dipanggil dan masa depan disediakan. Dengan menggunakannya, Anda bisa mendapatkan hasil eksekusi setelah tugas dieksekusi.

Mari kita pelajari cara menggunakan Callable, Future dan Futuretask.

Antarmuka yang dapat dipanggil

Antarmuka yang dapat dipanggil terletak di paket java.util.concurrent. Ini adalah antarmuka generik yang hanya menyatakan metode panggilan ():

 Antarmuka Publik Callable <T> {T call () melempar pengecualian;}

Secara umum, digunakan bersama dengan antarmuka ExecutorService. Beberapa metode pengiriman kelebihan beban dideklarasikan dalam antarmuka ExecutorService:

 <T> Masa Depan <T> Kirim (Tugas yang Dapat Dipanggil <T>); <T> Masa Depan <T> Kirim (Tugas Runnable, T Hasil); Future <?> Kirim (tugas yang dapat dijalankan);

Jenis parameter dalam metode pengiriman pertama dapat dipanggil, dan dua lainnya tidak dicakup oleh artikel ini untuk saat ini.

Masa depan dan futuretask

Kelas implementasi antarmuka di masa depan dapat melakukan operasi seperti membatalkan, menanyakan, dan mendapatkan hasil pada tugas yang dapat dijalankan atau dapat dipanggil.

Antarmuka masa depan juga terletak di bawah paket java.util.concurrent:

 Antarmuka Publik Masa Depan <T> { /***Batalkan tugas*@param mayInterruptifrunning*Apakah memungkinkan pembatalan tugas yang sedang dieksekusi tetapi tidak selesai? Jika benar ditetapkan, itu berarti bahwa tugas dalam proses dapat dibatalkan *Jika tugas sedang dieksekusi, ia mengembalikan true *jika tugas belum dieksekusi, ia mengembalikan benar apakah mungkin intruppifrunning adalah benar atau salah */ batal boolean (boolean mayintruptunning); /***Apakah tugas itu berhasil dibatalkan? Jika berhasil dibatalkan sebelum tugas selesai secara normal, ia mengembalikan true */ boolean iscancelled (); / ***Apakah tugas diselesaikan*/ boolean isDone (); / ***Dapatkan hasil eksekusi melalui blocking*/ t get () melempar interruptedException, ExecutionException; /***Dapatkan hasil eksekusi melalui pemblokiran. Jika tidak ada pengembalian yang dikembalikan dalam waktu yang ditentukan, kembalikan null */ t dapatkan (jual waktu lama, unit timeunit) melempar interruptedException, ExecutionException, timeoutexception;}

Singkatnya, Future menyediakan tiga fungsi:

 Tentukan apakah tugas selesai dan dapat mengganggu tugas dan mendapatkan hasil eksekusi tugas

JDK memberi kami kelas implementasi antarmuka masa depan Futuretask, yang memiliki dua konstruktor berikut.

 public futuretask (Callable <T> Callable) {} public futuretask (runnable runnable, t hasil) {}

Kode sampel

Menggunakan Callable, Masa Depan

 impor java.util.concurrent.*; tes kelas publik {public static void main (string [] args) {executorservice executorservice = executors.newcachedthreadpool (); Tugas tugas = tugas baru (); Future <Integer> Future = ExecutorService.submit (Tugas); ExecutorService.shutdown (); System.out.println ("Utas utama sedang mengeksekusi tugas ..."); coba {thread.sleep (2000); } catch (InterruptedException ex) {ex.PrintStackTrace (); } coba {System.out.println ("Hasil Jalankan Tugas:"+Future.get ()); } catch (InterruptedException ex) {ex.PrintStackTrace (); } catch (executionException ex) {ex.printstacktrace (); } System.out.println ("Semua tugas telah dieksekusi"); }} kelas tugas mengimplementasikan Callable <Integer> {@Override Public Integer Call () melempar Exception {System.out.println ("Thread anak mengeksekusi tugas ..."); // Tugas Simulasi Membutuhkan Time Thread.sleep (5000); mengembalikan 1000; }}

Hasil Eksekusi:

 Thread anak sedang menjalankan tugas ... utas utama sedang menjalankan tugas ... Hasil operasi tugas: 1000 semua tugas telah dieksekusi

Gunakan Callable, Futuretask

 impor java.util.concurrent.*; tes kelas publik {public static void main (string [] args) {executorservice executorservice = executors.newcachedthreadpool (); Tugas tugas = tugas baru (); Futuretask <Integer> futuretask = futuretask baru <Integer> (tugas); ExecutorService.submit (Futuretask); ExecutorService.shutdown (); System.out.println ("Utas utama sedang mengeksekusi tugas ..."); coba {thread.sleep (2000); } catch (InterruptedException ex) {ex.PrintStackTrace (); } coba {System.out.println ("Hasil Jalankan Tugas:"+futureTask.get ()); } catch (InterruptedException ex) {ex.PrintStackTrace (); } catch (executionException ex) {ex.printstacktrace (); } System.out.println ("Semua tugas dijalankan"); }} kelas tugas mengimplementasikan Callable <Integer> {@Override Public Integer Call () melempar Exception {System.out.println ("Thread anak sedang menjalankan tugas ..."); // mensimulasikan tugas mengambil thread.sleep (5000); mengembalikan 1000; }}

Hasil Eksekusi:

 Thread anak sedang menjalankan tugas ... utas utama sedang menjalankan tugas ... Hasil operasi tugas: 1000 semua tugas telah dieksekusi

Meringkaskan

Di atas adalah semua konten dari artikel ini tentang penggunaan Callable dan Masa Depan untuk pemrograman paralel di Java. Saya harap ini akan membantu semua orang. Teman yang tertarik dapat terus merujuk ke topik terkait lainnya di situs ini. Jika ada kekurangan, silakan tinggalkan pesan untuk menunjukkannya. Terima kasih teman atas dukungan Anda untuk situs ini!