Salinan kode adalah sebagai berikut:
paket com.yao;
impor java.util.concurrent.callable;
impor java.util.concurrent.executionException;
impor java.util.concurrent.executorservice;
impor java.util.concurrent.Executors;
impor java.util.concurrent.future;
impor java.util.concurrent.scheduledExecutorService;
impor java.util.concurrent.timeunit;
/**
* Arsitektur Eksekusi Tugas Baru.
* Sebelum Java 5.0, suatu tugas dimulai dengan memanggil metode start () dari kelas utas.
* Pengajuan dan eksekusi tugas dilakukan secara bersamaan.
* Atau mengendalikan jumlah utas yang dieksekusi secara bersamaan memerlukan kode tambahan untuk diselesaikan.
* 5.0 menyediakan arsitektur eksekusi tugas baru yang memungkinkan Anda untuk dengan mudah menjadwalkan dan mengontrol pelaksanaan tugas.
* Dan kumpulan utas yang mirip dengan kumpulan koneksi basis data dapat dibuat untuk melakukan tugas.
* Arsitektur ini terutama terdiri dari tiga antarmuka dan kelas spesifik yang sesuai.
*Ketiga antarmuka ini adalah pelaksana, ExecutorService dan JadwalExecutorService.
* (1) Antarmuka Eksekutor: Digunakan untuk menjalankan tugas yang dapat dijalankan, itu hanya mendefinisikan satu metode:
* Eksekusi (perintah runnable): Eksekusi tugas tipe RUANNABLE
* (2) ExecutorService: mewarisi metode pelaksana dan menyediakan layanan untuk melaksanakan tugas yang dapat dipanggil dan membatalkan eksekusi tugas.
* Metode utama definisinya adalah:
* Kirim (Tugas): Dapat digunakan untuk mengirimkan tugas yang dapat dipanggil atau dapat dijalankan dan mengembalikan objek masa depan yang mewakili tugas ini
* Invokeall (Koleksi Tugas): Koleksi Batch Tugas dan mengembalikan koleksi objek masa depan yang mewakili tugas -tugas ini.
* shutdown (): Tutup layanan setelah menyelesaikan tugas yang diajukan dan tidak lagi menerima tugas baru.
* shutdownnow (): Menghentikan semua tugas yang mengeksekusi dan menutup layanan.
* Isterminated (): Uji apakah semua tugas telah dieksekusi.
* isShutdown (): Uji apakah ExecutorService telah ditutup
* (3) Terjadwal ExecutorService: mewarisi ExecutorService, memberikan fungsi tugas penjadwalan sesuai waktu,
* Jadwal (Tugas, InitDelay): Jadwalkan tugas yang dapat dipanggil atau dapat dijalankan untuk dieksekusi setelah waktu yang ditentukan oleh InitDelay.
* SCRECTULEAtFIXEDRATE (): Jadwalkan tugas yang dapat diajukan untuk dieksekusi berulang kali pada interval yang ditentukan.
* SCHORDUWITHFIXEDDELAY (): Jadwalkan tugas runnable yang diajukan untuk dieksekusi berulang kali setelah setiap eksekusi, tunggu waktu yang ditentukan oleh penundaan.
*
* Dapatkan berbagai objek layanan melalui kelas pelaksana.
* Callable (Tugas Runnable): Konversi Tugas Runnable menjadi tugas yang dapat dipanggil
* NewsingLetHreadExecutor: Menghasilkan objek ExecutorService, yang hanya memiliki satu utas yang dapat digunakan untuk menjalankan tugas.
* NewcachedThreadPool (): Menghasilkan objek ExecutorService, yang memiliki kumpulan utas.
* NewfixedThreadPool (int poolsize): Menghasilkan objek ExecutorService, yang memiliki kumpulan utas ukuran poolsize.
* NewsingLetHreadsCheduledExecutor: Menghasilkan objek jadwal yang dijadwalkan, ukuran kumpulan utas dari objek ini adalah 1. Jika ada lebih dari satu tugas, tugas akan dieksekusi secara berurutan.
* NewsCheduledThreadPool (int poolsize): Menghasilkan objek jadwal yang dijadwalkan, ukuran kumpulan utas dari objek ini adalah kumpulan.
*/
Executearch kelas publik {
/**
* Thread ini menghasilkan string
*/
kelas statis public mythread mengimplementasikan runnable {
public void run () {
System.out.println ("Pengulangan Tugas." + System.CurrentTimeMillis ());
mencoba {
Thread.sleep (1000);
} catch (InterruptedException e) {
System.out.println ("Tugas terganggu."
+ System.currentTimemillis ());
}
}
}
/**
* Callable mengakhiri tugas lain
*/
kelas statis public myCallable mengimplementasikan callable {
masa depan masa depan pribadi;
Public MyCallable (Future Future) {
this.future = masa depan;
}
call string publik () {
System.out.println ("Untuk membatalkan tugas ..."
+ + System.currentTimeMillis ());
this.future.cancel (true);
kembalikan "tugas dibatalkan!";
}
}
/**
* @param args
* @Throws ExecutionException
* @Throws InterruptedException
*/
public static void main (string [] args) melempar interruptedexception,
ExecutionException {
// Hasilkan objek ExecutorService, yang memiliki kumpulan benang, dan ukuran kumpulan benang akan disesuaikan sesuai kebutuhan.
// Setelah utas menjalankan tugas, ia kembali ke kumpulan utas untuk tugas selanjutnya yang akan digunakan.
ExecutorService CachedService = Executors.NewCachedThreadPool ();
Masa depan mythreadfuture = CachedService.submit (myThread baru ());
Future MycallableFuture = CachedService.Submit (MyCallable baru (
MyThreadFuture));
System.out.println (MyCallableFuture.get ());
System.out.println ("-----------------");
// Konversi tugas runnable menjadi tugas yang dapat dipanggil
Callable mythreadcallable = executors.callable (new mythread ());
Masa depan mythreadcallableFuture = cacheedservice.submit (mythreadcallable);
// Untuk tugas yang dapat dijalankan, tidak ada nilai yang dikembalikan setelah dikonversi ke tugas yang dapat dipanggil
System.out.println (MyThreadCallableFuture.get ());
CachedService.shutdownnow ();
System.out.println ("-----------------");
// Hasilkan objek ExecutorService, yang memiliki kumpulan ulir ukuran kumpulan.
// Jika jumlah tugas lebih besar dari kumpulan, tugas akan dieksekusi dalam antrian secara berurutan
ExecutorService FixedService = Executors.newfixedThreadPool (2);
fixedservice.submit (myThread baru ());
fixedservice.submit (myThread baru ());
// Karena ukuran kumpulan utas adalah 2, tugas -tugas selanjutnya harus menunggu tugas -tugas sebelumnya dieksekusi sebelum dapat dieksekusi.
myThreadFuture = fixedservice.submit (mythread baru ());
mycallableFuture = fixedservice.submit (mycallable baru (mythreadfuture));
System.out.println (MyCallableFuture.get ());
fixedservice.shutdownnow ();
System.out.println ("-----------------");
// Hasilkan objek yang dijadwalkan ExcecutorService, ukuran kumpulan utas dari objek ini adalah kumpulan.
// Jika jumlah tugas lebih besar dari kumpulan, tugas akan menunggu eksekusi dalam antrian
Terjadwal executorService FixedscheduledService = Executors
.newscheduledThreadPool (2);
// Buat tugas baru 1
MyThread Task1 = myThread baru ();
// Gunakan Layanan Eksekusi Tugas untuk menjalankan Tugas 1 segera, dan kemudian jalankan Tugas 1 setiap 2 detik sesudahnya.
myThreadFuture = fixedscheduledservice.scheduleatFixedrate (Task1, 0, 2,
Timeunit.seconds);
// Buat tugas baru 2
MyCallable Task2 = mycallable baru (myThreadFuture);
// Gunakan Layanan Eksekusi Tugas untuk menunggu 5 detik sebelum melaksanakan Tugas 2. Setelah menjalankannya, Tugas 1 akan ditutup.
mycallableFuture = fixedscheduledservice.schedule (Task2, 5,
Timeunit.seconds);
System.out.println (MyCallableFuture.get ());
fixedscheduledservice.shutdownnow ();
}
}