Antarmuka yang dapat dipanggil dan masa depan
Callable adalah antarmuka yang mirip dengan Runnable.
Ada beberapa perbedaan antara Callable dan Runnable:
(1) Metode yang ditentukan oleh Callable adalah call (), sedangkan metode yang ditentukan oleh Runnable adalah run ().
(2) Tugas yang dapat dipanggil dapat mengembalikan nilai setelah dieksekusi, sedangkan tugas yang dapat dijalankan tidak dapat mengembalikan nilainya.
(3) Metode panggilan () dapat melempar pengecualian, sedangkan metode run () tidak dapat melempar pengecualian.
(4) Jalankan tugas yang dapat dipanggil dan Anda bisa mendapatkan objek di masa depan.
Ini memberikan metode untuk memeriksa apakah perhitungan selesai, menunggu perhitungan selesai, dan untuk mengambil hasil perhitungan.
Melalui objek masa depan, Anda dapat memahami status eksekusi tugas, membatalkan eksekusi tugas, dan juga mendapatkan hasil eksekusi tugas.
Salinan kode adalah sebagai berikut:
paket com.yao;
impor java.util.concurrent.callable;
impor java.util.concurrent.executorservice;
impor java.util.concurrent.Executors;
impor java.util.concurrent.future;
CallableAndFuture kelas publik {
/**
* Kustomisasi kelas tugas untuk mengimplementasikan antarmuka yang dapat dipanggil
*/
Kelas statis publik MyCallableClass mengimplementasikan Callable {
// Posisi logo
bendera int pribadi = 0;
public mycallableClass (int flag) {
this.flag = bendera;
}
Publik string call () melempar Exception {
if (this.flag == 0) {
// Jika nilai bendera adalah 0, segera kembalikan
kembalikan "bendera = 0";
}
if (this.flag == 1) {
// Jika nilai bendera adalah 1, lakukan loop tak terbatas
mencoba {
while (true) {
System.out.println ("Looping ...");
Thread.sleep (2000);
}
} catch (InterruptedException e) {
System.out.println ("interrupted");
}
mengembalikan "false";
} kalau tidak {
// Jika false bukan 0 atau 1, pengecualian akan dilemparkan
Lempar pengecualian baru ("Nilai Bendera Buruk!");
}
}
}
public static void main (string [] args) {
// Tentukan 3 jenis tugas yang dapat dipanggil
MyCallableClass Task1 = MyCallableClass baru (0);
MyCallableClass Task2 = MyCallableClass baru (1);
MyCallableClass Task3 = MyCallableClass baru (2);
// Buat layanan yang melakukan tugas
ExecutorService es = executors.newfixedThreadpool (3);
mencoba {
// Kirim dan jalankan tugas.
// Jika Anda ingin mendapatkan hasil pelaksanaan tugas atau pengecualian, Anda dapat beroperasi pada objek masa depan ini
Future Future1 = Es.submit (Task1);
// Dapatkan hasil tugas pertama.
System.out.println ("Task1:" + Future1.get ());
Future Future2 = Es.submit (Task2);
// tunggu selama 5 detik sebelum menghentikan tugas kedua. Karena tugas kedua adalah loop yang tak terbatas
Thread.sleep (5000);
System.out.println ("Task2 Batal:" + Future2.cancel (true));
// Dapatkan output dari tugas ketiga, karena melaksanakan tugas ketiga akan menyebabkan pengecualian
// Jadi pernyataan berikut akan menyebabkan pengecualian dilemparkan
Future Future3 = Es.submit (Task3);
System.out.println ("Tugas3:" + Future3.get ());
} catch (Exception e) {
System.out.println (e.tostring ());
}
// Hentikan Layanan Eksekusi Tugas
es.shutdownnow ();
}
}